Java面试题全集学习笔记

学习资料来自：

http://blog.youkuaiyun.com/jackfrued/article/details/44921941/

第7题！

class AutoUnboxingTest {

    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 将3自动装箱成Integer类型
        int c = 3;
        System.out.println(a == b);     // false 两个引用没有引用同一对象
        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
        System.out.println(b == c);    // true b自动拆箱成int类型再和c比较 
    }
}

public class B{
    public static void main(String[] args) {
        Integer a = 128;
        Integer b = 128;
        int c = 128;
        System.out.println(b==a);//false
        System.out.println(a==c);//true
        System.out.println(b==c);//true
    }

}

public class B{
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        int c = 100;
        System.out.println(b==a);
        System.out.println(a==c);
        System.out.println(b==c);
    }

}

之所以会出现上面神奇的现象，是因为

Integer a = 100时，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，但如果超过128，就会new新的Integer对象。

但是Integer a = new Integer(3)时，由于后面用了new，所以无论如何都会new一个Integer出来。

但是用==进行比较的时候，装箱的a和b(128时b也装箱)会自动拆箱成int类型与c进行比较，拆箱后引用指向的就变了，变为了常量池中的int型数值位置

18题！

Java语言的方法调用只支持参数的值传递！虽然传递的是对象的句柄副本，但真正操作起来的还是对象本身。

24题！

class Outer {

    class Inner {}

    public static void foo() { new Inner(); }

    public void bar() { new Inner(); }

    public static void main(String[] args) {
        new Inner();
    }
}

Java中非静态内部类对象的创建要依赖其外部类对象，上面的面试题中foo和main方法都是静态方法，静态方法中没有this，也就是说没有所谓的外部类对象，因此无法创建内部类对象，如果要在静态方法中创建内部类对象，可以这样做：

new Outer().new Inner();

在其他类中用到时

Outer outer= new Outer();
Outer.Inner inner = outer.new Inner();

37题！

创建对象时构造器的调用顺序是：先初始化静态成员，然后调用父类构造器，再初始化非静态成员，最后调用自身构造器。

46题！
try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会被执行，在return前执行。果存在finally代码块，try中的return语句不会立马返回调用者，而是记录下返回值待finally代码块执行完毕之后再向调用者返回其值，然后如果在finally中修改了返回值，就会返回修改后的值。

51题！

下面代码输出什么？

class Annoyance extends Exception {}
class Sneeze extends Annoyance {}

class B {

    public static void main(String[] args)
            throws Exception {
        try {
            try {
                throw new Sneeze();
            }
            catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        }
        catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
            return ;
        }
        finally {
            System.out.println("Hello World!");
        }
    }
}

输出：

Caught Annoyance
Caught Sneeze
Hello World!

原因：

虽然第一个catch那里捕获的是Annoyance，但是由于throw的是一个Sneeze而它又是Annoyance的子类，所以那个a其实还是Sneeze类型的，所以catch后又抛出，还能被第二个catch捕获！

57题！

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位；线程是进程的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位。线程的划分尺度小于进程，这使得多线程程序的并发性高；进程在执行时通常拥有独立的内存单元，而线程之间可以共享内存。使用多线程的编程通常能够带来更好的性能和用户体验，但是多线程的程序对于其他程序是不友好的，因为它可能占用了更多的CPU资源。当然，也不是线程越多，程序的性能就越好，因为线程之间的调度和切换也会浪费CPU时间。