笔试题 - 卷2 - 《Java技术》

解析：
编译不会编译注释。

解析：
局部变量使用之前必须初始化，否则报错。
但是！！如果是静态变量，可以不用初始化，因为在类的加载的准备阶段，会为静态变量赋默认初值。

public class TestInitParameter {
    static int i;
    public static void main(String[] args) {
        System.out.println(i);
    }
}
// 输出0

此外！！！如果是成员变量，在new对象的过程中也会赋默认初值，因此也可以不用初始化，重要调用了new就可以用了。

public class TestInitParameter {
    int j;
    public static void main(String[] args) {
        TestInitParameter obj = new TestInitParameter();
        System.out.println(obj.j);
    }
}

解析：
没有jinfo这个命令

jmap查看内存映射，映射就是map，记住

jhat是内存分析工具

jstat是性能监控工具。

解析：
char类型的默认值是’\u0000’

解析：
标识符不能以数字开头，只能以字母，_ 和 $开头。

解析：

解析：
System.arraycopy调用的是本地方法，所以最快。

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

clone也是本地方法，但是比System.arraycopy稍微慢

Array.copyOf本质还是调用System.arraycopy，排第三

    public static boolean[] copyOf(boolean[] original, int newLength) {
        boolean[] copy = new boolean[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

for遍历最慢。

解析：
如果是成员方法，确实是运行new出来的对象的方法；

但是如果是静态方法，就是运行左边类对应的方法。

public class TestStaticExtends {
    public static void main(String[] args) {
        FatherTest f = new SonTest();
        f.staticMethod();
        f.normalMethod();
    }

}

class FatherTest {
    public static void staticMethod() {
        System.out.println("Father's static method");
    }

    public void normalMethod() {
        System.out.println("Father's normal method");
    }
}

class SonTest extends FatherTest {
    public static void staticMethod() {
        System.out.println("Son's static method");
    }

    public void normalMethod() {
        System.out.println("Son's normal method");
    }
}

输出：
Father's static method
Son's normal method

解析：
A错是因为JAVA是跨平台的，包和操作系统没有任何关系，而是虚拟文件系统；

B错是因为，并没有拷贝过来执行，而是告诉编译器有使用外部文件，去找外部文件。

C错的明显

D，有人可能以为用private修饰类，那在同一个包下就不能访问，但是！外部类不能用private修饰！只要内部类可以。！！

解析：
虚拟机并不知道泛型，因为在编译过程中，会进行泛型的擦除；所以A和B正确；

创建泛型对象时要指明类型，让编译器尽早进行参数检查，而不是等到运行时抛错，因此C正确；

D错误，因为可以通过反射的方式获得实际类型。

解析：
count = count++:

先将count保存到副本里，即temp = count;
将temp赋值给count，即count = temp; 因此count仍然为0；
完成temp的++，而不是count的++，因此temp为1， count为0.

注意，如果改成++count，就不会出现这种问题：

public class TestSelfIncrement {
    public static void main(String[] args) {
        int count = 0;

        for (int i = 0; i < 10; i++) {
            count = ++count;
        }

        System.out.println(count);
    }
}

输出为10

原因是：

先将count保存到副本里，temp= count；
temp自增，temp = 1;
将temp赋值给count，那么count = 1;

可以看到，2和3的顺序调换了。

解析：

被final修饰的是常量，b6 = b4 + b5可以直接看出b6 = 4 + 6 = 10; 不涉及类型的转换；
但是没有被final修饰的byte, short, char，在进行计算时，都会变转化成Int类型，因此b3 = b1 + b2会编译出错，因为b3是byte类型的，而b1 + b2返回的是int类型的。

public class TestByte {
    public static void main(String[] args) {
        byte b1, b2, b3;
        b2 = 1;
        b3 = 1;
        b1 = b2 + b3;
    }
}

解析：
interface类只能缺省或者用Public修饰。

解析：
Stream结尾都是字节流；

Reader，writer结尾都是字符流。

二者实际使用的时候差不太多，如果在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。

解析：
Map下线程安全的有HashTable(目前不咋用了)，和ConcurrentHashMap；

此外，可以通过Collections.synchronizedXXX()包装成线程安全的集合。

解析：
A错误是因为是字符串，要用双引号；

B错误是因为要用str.length()方法，不是属性，只有数组才是属性;

C错是因为没有进行强制转型，类型不匹配；

D正确是因为会当做字符串的拼接处理，等号两边仍然是字符串。