java知识要点整理

1.protected，default，public，private

private： 同一类内可见
default： 同一包内可见
protected： 同一包内的类和所有子类可见
public： 所有类可见

举例：

2.面向对象的三个特征

封装： 通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。
继承： 它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

继承类叫做子类，基类。被继承的类叫做父类，派生类，或超类 在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。 如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

private String name;
private String sex;
public xinxin1(String name,String sex)
{
     this.name=name;
     this.sex=sex;
}

public void hello(){
System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);
    }
子类：
public xinxin2(String name,String sex)
{
     //调用父类的构造方法
    super(name,sex);

}

public void hello(){
System.out.println(“我是新来的！”);
 //调用父类的方法
    super.hello();
}
复制代码

多态： 形参一定是父类的引用，而实参可以是它任何一个子类的引用。

举例

public class Animal {
    public void shout(){
        System.out.println("吼吼......");
    }
}

定义一个狗类，继承自动物类，重写“叫”的方法

public class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪");
    }
}

定义一个猫类

public class Cat extends Animal {

    public void shout() {
        System.out.println("喵喵");
    }
}

测试程序

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        Cat c = new Cat();

        hit(d);
        hit(c);

    }
   private static void hit(Dog d) {
        d.shout();
    }
    private static void hit(Cat c) {
        c.shout();
 }
    }
复制代码

3.基本数据类型

byte，short，int，long，float，double，char，boolean

string是引用类型，不是基本数据类型

4.Java有没有goto？

goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义

5.int和integer有什么区别？

int是基本数据类型，integer是一个类

6.Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？

Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

7.数组有没有length()方法？String有没有length()方法？

数组没有length()方法，有length的属性。String有length()方法

8.在java中如何跳出多重嵌套循环？

在最外层循环前加一个标记如A，然后用break A


public class Test3 {
	public static void main(String[] args) {
		method1();
		method2();
	}
	//方法一：
	public static void method1(){
		ok:for(int i=0;i<10;i++){
			for(int j=0;j<10;j++){
				System.out.println("i="+i+",j="+j);
				if(j==5){
					break ok;//跳到循环外的ok出，即终止整个循环
				}
			}
		}
	}
复制代码

9.两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？

对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。Java对于eqauls方法和hashCode方法是这样规定的：

如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；
如果两个对象的hashCode相同，它们并不一定相同。

10.是否可以继承String类？

String类是final类，不可以被继承。

11.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

值传递

11.重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。

12.final关键字的用法？

修饰类，表示该类不能被继承
修饰方法，表示该方法不能被重写。
修饰变量，赋值一次后不能更改。

13.抽象类和接口有什么异同？

抽象类和接口都不能实例化
一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类
抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。
抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

14.是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？

不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并没有被初始化。

15.Thread类的sleep()和对象的wait()方法都可以让线程暂停执行，它们有什么区别？

sleep()是Thread的静态方法，调用此方法线程会暂停执行，将CPU让给其他进程，但是对象的锁会依然保持，休眠结束后会自动恢复。
wait()是Object类的方法，调用wait()方法导致当前线程放弃对象的锁，进入对象的等待池，只有调用对象的notify()方法才能将其唤醒。

16.线程的sleep()方法和yeild()方法有什么区别？

sleep()方法给其他进程机会是不考虑线程的优先级，因此会给低优先级的进程以运行机会，yield()方法只会给相同优先级或更高优先级的线程运行机会。
sleep()方法转入阻塞状态，而yeild()方法转入就绪状态。
sleep()方法声明后抛出InterruptedException，而yield()方法没有声明任何异常。

17.编写多线程程序的几种方式？

一种是继承Thread类；另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为，推荐使用后者，因为Java中的继承是单继承，一个类有一个父类，如果继承了Thread类就无法再继承其他类了，显然使用Runnable接口更为灵活。

thread继承

public class MultiThread_Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
    }
}

class MyThread extends Thread {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
复制代码

实现runnable接口

public class MultiThread_Test {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        new Thread(mr).start();
    }
}

class MyRunnable implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
复制代码

18.synchronized用法

synchronize修饰代码块和方法

修饰代码块 一个线程访问后其他线程才可以访问

class MyThread implements Runnable {
    private int count;

    public MyThread() {
        count = 0;
    }

    public  void run() {
        //同步代码块中锁定的是当前实例对象
        synchronized(this) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

修饰方法

class MyThread implements Runnable {
   private static int count;

   public MyThread() {
      count = 0;
   }

   public synchronized static void method() {
      for (int i = 0; i < 5; i ++) {
         try {
            System.out.println(Thread.currentThread().getName() + ":" + (count++));
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
   
   public void run() {
      method();
   }
}
复制代码

19.什么是线程池？

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

20.Error和Exception有什么区别？

Error表示系统级错误，仅靠程序本身无法恢复和预防，建议让程序终止
Exception表示程序可以处理的异常，可以捕捉并且可以恢复。

21.finally关键字

无论是否发生异常，finally代码块中的关键字都会被执行，一般是运行清理收尾性质的语句。 finally代码块出现在catch语句的最后。finally中使用return是一种非常不好的编程风格，它会覆盖掉所有的返回，并且吃掉catch中的异常。

语法

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}
复制代码

当try或catch中遇到return语句时，finally语句会在方法返回前被执行。在finally语句发生了异常，finally块不会被执行。