卷1

解析：
Java八种基础数据类型：
字符型：char;
布尔型：boolean;
整数类型：byte, short, int ,long;
浮点型：double, float.

解析：
A错的明显

B，String底层在1.8的和之前是采用char数组，但是1.8以后采用的是byte数组，因为Java开发者发现通常放入的字符都小于两个字节，因此用char会导致浪费，因为char占两个字节。所以改成了byte，byte只用一个字节，更加节省空间。

C, 正确，因为String重写了equals方法，对比的是字符串里的内容:

    public boolean equals(Object anObject) {
        // 如果是同一个对象，直接返回true
        if (this == anObject) {
            return true;
        }
        // 如果是String的实例对象
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            // 如果长度相等（不相等肯定为false）
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                // 按位比较每一个字符的值
                // 有一位不相等则返回false
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

D。 char类型里存储的是unicode, 要不然怎么存储汉字呢？？

解析：
Java在做混合计算时，会自动转化成所有数据类型转化为容量最大的那种类型，比如：
100 % 3.0 => 转化成float % float，因此结果也是float类型，即1.0

javac -d
-d d是destination的缩写，所以是指定生成的类文件的目录；

javac -s
-s s是source的缩写，所以是指定源文件的目录；

解析：
构造函数一般是public的，或者改成protected, private （例如单例模式下）;

但是构造函数不能被final修饰，因为构造函数不能被继承，用final修饰没意义；

不能被static修饰，因为是当new一个对象的时候调用的；

也不能被sychronized和native修饰；

当try里有return时，不会立马执行，而是开启一个临时栈，将要return回去的值压到栈里，然后去执行finally里的值，等到finally里的运行结束了，再去运行try里的return。

这里有个特殊情况，如果finally里和try里都有return语句，那么try里return语句不会去执行了。

public class testFinally {
    public static void main(String[] args) {
        System.out.println(returnSomething());
    }

    private static int returnSomething() {
        try {
            return 1;
        } finally {
            return 2;
        }
    }
}

输出是2，而不是1.

解析：

1. 继承和实现接口的时候，会继承变量吗？

会继承，只要不是private的。

1. 静态变量能通过对象.静态变量的方式使用吗？不会报错吗？

可以！不会报错.

public class testExtensStatic {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.i);
    }
}

class Son extends Father {

}

class Father {
    public static int i = 10;
}

// 输出10

1. 接口里的变量缺省时是被哪些关键字修饰的？

是被public static final修饰的，可以当成常量。

因此对于本题来说，输出为10。

解析：

1. 静态变量是可以被对象.静态变量得到的；
2. 静态变量是共享的，所以一共被加了3次，减了1次，因此是102.

解析：

1. List和Set里都是允许存放null的；
2. 只是因为Set保证了唯一性，所以只有一个Null;

解析：

public static double floor(double a) {
    return StrictMath.floor(a); // default impl. delegates to StrictMath
}

如上，Math.floor方法返回类型就是double类型。

解析：
注意修饰符，name是用private修饰的，所以子类访问不了，如果改成public就没问题了。

解析：
只要是被子类重写了的方法，没有通过super调用，那都是去调用子类里的重写方法。

解析：
Byte是包装类型，不是byte, 默认初始化为null， null + “”仍然还是null；

System.out.println(null + "");

// 输出仍然是null

总结：

1. Map下各种map + HashTable
2. Collection下各种List + 各种set + Queue + Vector + Stack。

解析：

1. 构造函数私有
2. 唯一实例

注意：
并不一定需要静态工厂方法，只要有一个静态方法能返回这个实例就可以了。

解析：
Java需要通过重写和重载实现多态。

重写是覆盖，是子类对父类的重写；

重载是在一个类里对同名方法的重载。

解析：
final不能修饰抽象类，因为一旦可以修饰抽象类，那么该抽象类就不能被继承。一个抽象类如果不能被继承，那还有什么意义呢？

此外，final也不能修饰接口。

final修饰方法只是不能被重写，但是可以被重载。

解析：
B、C、D都是Object的方法，

A是关键字，不是方法

sleep()是线程的方法。

解析：
A、B、C均正确

D表述不正确，是在return完成之前，事实上执行到catch以后，执行return并不会立刻返回，而是将要返回的值暂存起来，然后执行finally语句，如果finally没有return，就会返回回去执行catch里的return