java基础知识点、面试选择题归纳整理

前言

之前刷了一些题，为了方便自己日后可以快速的查缺补漏以及方便有需要的人，这里整理了一些个人感觉比较有意义的选择题，题目均来自牛客网的java相关选择题。
如各位看官发现哪里写的不对的，请帮忙指出，谢谢。
题目基本就更新完了(2018.01.30)
ps：答案设置成了白色字体，想要看答案，只需选中答案那一行即可看到答案。

正文

一、陷阱之i等于i自增

1.以下代码执行的结果显示是多少（）？

public class Inc {
    public static void main(String args[]){
        Inc inc = new Inc();
        int i = 0;
        inc.fermin(i);
        i = i++;
        System.out.println(i);
    }
    void fermin(int i){
        i++;
    }
}

A. 0
B. 1
C. 2
D. 3

答案：A
笔记：
对于i=i++，先是执行i++，i自增1并返回自增前的值，因此如果i的初始值为0，那么执行i++，i变成1，并返回自增前的值，也就是0，再执行赋值操作，因此i=0。故先A。记住，遇到i=i++，i的值不变。

2.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果（）

public class Demo {
    public static void main(String args[]){
        int count = 0;
        int num = 0;
        for(int i=0;i<=100;i++){
            num = num+i;
            count = count++;
        }
        System.out.println(num*count);
    }
}

A. 505000
B. 0
C. 运行时错误
D. 5050

答案：B

二、正则表达式

1.Java中用正则表达式截取字符串中第一个出现的英文左括号之前的字符串。比如：北京市（海淀区）（朝阳区）（西城区），截取结果为：北京市。正则表达式为（）
A. “.*?(?=\()”
B. “.*?(?=()”
C. “.*(?=\()”
D. “.*(?=()”

答案：A
笔记：
.表示匹配\n除外的任何字符，*表示匹配0个或多个，.*后接?表示非贪婪匹配，(?=pattern)，即正向肯定预查，这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。因此(?=\\()表示匹配左括号。
正则表达式参考网址：http://www.runoob.com/regexp/regexp-metachar.html

2.关于下面的程序，哪一个选项是正确的输出结果（）

    public static void main (String[] args) { 
        String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
        System.out.println(classFile);
    }

A. com. jd
B. com/jd/MyClass.class
C. ///////MyClass.class
D. com.jd.MyClass

答案：C
笔记：
public String replaceAll(String regex,String replacement),有该方法的声明可知第一个参数是regex，即表示正则表达式的字符串，而在正则表达式中，”.”表示的是除\n外的任意字符，因此原字符串中的”com.jd.”都会被替换成”/”，如果想要达到正确的结果，则需要使用转移符号，即改成：replaceAll(“.”, “/”)，这样就能得到”com/jd/MyClass.class”这个结果。

三、关键字相关题目

1.关于下面的程序，说法正确的是（）

public class Demo {
    static String x = "1";
    static int y = 1;
    public static void main (String[] args) { 
        static int z= 2;
        System.out.println(x+y+z);
    }       
}

A. 3
B. 112
C. 13
D. 程序有编译错误

答案：D
笔记：
static变量是类变量，不能定义在方法中。

2.true、false、null、sizeof、goto、synchronized 哪些是Java关键字（）
A. true
B. false
C. null
D. sizeof
E. goto
F. synchronized

答案：EF
笔记：
goto和const既是保留字也是关键字。除了这两个之外，关键字和保留字是严格区分开的。
null、true、false是保留字。所谓保留字，就是现有java版本尚未使用，但以后版本可能会作为关键字使用。
关键字有50个，保留字有14个。
而sizeof是C语言中的关键字，在java中并不是。

3.以下关于final关键字说法错误的是（）
A final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B final修饰的类肯定不能被继承
C final修饰的方法不能被重载
D final修饰的变量不允许被再次赋值

答案：C
笔记：
final修饰类表示类不可被继承，修饰方法表示方法不可被重写，修饰常量表示引用不可改。

4.有关下述Java代码描述正确的选项是（）

public class TestClass {
   private static void testMethod(){
        System.out.println("testMethod");
   }
   public static void main(String[] args) {
        ((TestClass)null).testMethod();
   }
}

A. 编译不通过
B. 编译通过，运行异常，报NullPointerException
C. 编译通过，运行异常，报IllegalArgumentException
D. 编译通过，运行异常，报NoSuchMethodException
E. 运行正常，输出testMethod

答案：E
笔记：
将null强制转换成TestClss类型，因此((TestClass)null)这个整体也就表示一个TestClass类型的对象了。
static成员属于类成员（成员包括属性和方法），static方法，即类方法，可以直接通过”类名.方法名”进行访问。但static方法也可以通过”对象.方法名”进行访问，也就是说我们可以通过类的实例去调用，但其实质是转化成类来调用。

5.在使用super和this关键字时，以下描述正确的是（）
A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B super（）和this（）不一定要放在构造方法内第一行
C this（）和super（）可以同时出现在一个构造函数中
D this（）和super（）可以在static环境中使用，包括static方法和static语句块

答案：A
笔记：
this()和super()都必须写在第一行，因此不能同时出现在同一个构造方法中。
super()调用的是父类的构造器，this()调用的是同一类中重载的构造器。
static方法中无法使用this关键字。且this()和super()只能出现在构造方法中。

6.关键字super的作用是()
A 用来访问父类被隐藏的非私有成员变量
B 用来调用父类中被重写的方法
C 用来调用父类的构造函数
D 以上都是

答案：D
笔记：
super代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法、以及构造方法。

四、多态

1.对于如下代码段,可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）

class A{
    public A foo(){
        return this;
    }
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B{
    _______
}

A. public void foo(){}
B. public int foo(){return 1;}
C. public A foo(B b){return b;}
D. public A foo(){return A;}

答案：C
笔记：
A和B，返回值类型类B的foo方法不一样，因此，不可能是方法重写，因此，只有可能是方法重载，但是方法重载又要求方法形参列表不同，因此，也不可能是方法重载。因此，无法通过编译。
继续分析C，由于C选项的foo方法形参列表与类B的形参列表不同，因此，不可能是方法重写，只可能是方法重载，而C选项的foo方法满足方法重载的所有要求（方法名相同、形参列表不同），因此C选项正确。
D，返回A，编译不通过。

2.（多选题）类Parent和Child定义如下，对于如下代码段，可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）

class Parent{
    public float aFun(float a, float b){return a+b;}
}
class Child extends Parent{
    _______
}

A. float aFun(float a, float b){return a+b;}
B. public int aFun(int a, int b){return a+b;}
C. public float aFun(float a, float b){return a+b;}
D. private int aFun(int a, int b){return a+b;}

答案：BCD
笔记：
对于BD选项，方法形参列表不同，因此不可能是方法重写，只可能是方法重载，方法重载的条件是方法名相同，形参列表不同，因此，满足条件。（方法重载无关返回值类型和方法访问权限）。
对于AC选项，形参列表相同，因此不可能是方法重载，因此只可能是方法重写。方法重写条件：两同两小一大，C均满足，A不满足”一大”。
具体分析A，普通类方法的默认访问权限是包内访问权限，也就是default，但不能显式的写default，由于父类的aFun方法的访问权限是public，对于方法重写，子类重写的方法的访问权限不应小于父类方法的访问权限，故A错。

3.以下方法，哪个不是对add方法的重载()

public class Test{
    public void add( int x,int y,int z){}
}

A. public int add(int x,int y,float z){return 0;}
B. public int add(int x,int y,int z){return 0;}
C. public void add(int x,int y){}
D. 以上都不是

答案：B
笔记：
重载规则：方法名相同，形参列表不同。B的话形参列表和方法名都与Test类中的add方法相同。返回值类型、方法访问权限无关重载。

4.下列哪些针对代码运行结果的描述是正确的？

public class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new Car().run();
    }
    private final void run()
    {
        System.out.println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System.out.println("Vehicle");
    }
}

A. Car
B. Vehicle
C. Compiler error
D. Exception thrown at runtime

答案：A
笔记：
final修饰方法表方法不可重写。而private修饰方法，表示该方法是私有方法，即子类不可见。因此在这道题中，类Car中的run方法和父类Vehicle中的run方法没有任何关系。也就是说不存在方法重写与重载。因此，当执行new Car()时，执行的是子类的run方法。并且没有编译错误，运行时也不会出现异常。

5.下列程序执行后结果为( )

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

A Result=150 Result=150
B Result=100 Result=100
C Result=100 Result=150
D Result=150 Result=100

答案：A
笔记：
对于方法，非静态：编译看左，运行看右 静态成员变量：都看左。
1.成员变量：编译和运行都参考左边。
2.成员函数（非静态）：编译看左边，运行看右边
3.静态函数：编译和运行都看左边。

6.这个程序的输出结果是（）

package Wangyi;
class Base
{
    public void method()
    {
        System.out.println("Base");
    } 
}
class Son extends Base
{
    public void method()
    {
        System.out.println("Son");
    }

    public void methodB()
    {
        System.out.println("SonB");
    }
}
public class Test01
{
    public static void main(String[] args)
    {
        Base base = new Son();
        base.method();
        base.methodB();
    }
}

A Base SonB
B Son SonB
C Base Son SonB
D 编译不通过

答案：D
笔记：
Base base = new Son();
这句new 了一个派生类，赋值给基类，所以下面的操作编译器认为base对象就是Base类型的
Base类中不存在methodB()方法，所以编译不通过。
对于成员函数：编译看左边，运行看右边。意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。
1.成员变量：编译和运行都参考左边。
2.成员函数（非静态）：编译看左边，运行看右边
3.静态函数：编译和运行都看左边。

7.在java的多态调用中，new的是哪一个类就是调用的哪个类的方法（）
A 对
B 错

答案：B
笔记：
1.成员变量：编译和运行都参考左边。
2.成员函数（非静态）：编译看左边，运行看右边
3.静态函数：编译和运行都看左边。
举例如：

public class Demo{
    public static void main(String[] args){
        P p = new M();
        p.f();
    }
}
class P{
    public static void f(){
        System.out.println("parent");
    }
}
class M extends P{
}

尽管new的是类M，但调用的是父类P的方法，除非子类重写了该方法。

8.对于如下代码段

class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B
{
    _______
}

可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）
A public void foo(){}
B public int foo(){return 1;}
C public A foo(B b){return b;}
D public A foo(){return A;}

答案：C
笔记：
很明显考的是重载和重写，对于AB，返回值类型与父类方法的返回值类型不同，因此肯定不是方法重写，因此只可能是方法重载，但重载又要求形参列表必须不同，因此也不可能是重载，因此AB编译不通过。对于D，返回A，很明显是有问题的。对于C，形参列表不同，因此是方法重载。

总结：方法重写Override与方法重载Overload

方法重写：
子类方法重写父类方法遵循“两同两小一大”的规则：
“两同”即方法名相同，形参列表相同
“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等（这是因为返回值类型更大或者更小，是对于同一类型而言的。也就是说，返回值的类型需要有继承关系才去考虑大小这个概念。类型不同，肯定不是方法重写）
“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
方法重载：
重载是一个类中出现多个同名的方法。因此，我们考虑重载，是在类中有同名方法的前提下。
方法名相同、方法形参列表不同。

五、修饰符问题

1.以下声明合法的是（）
A. default String s;
B. public final static native int w();
C. abstract double d;
D. abstract final double hyperboilcCosine;(hyperboilcCosine译为双曲余弦函数)

答案：B
笔记：
在类中不能显式的用default修饰变量和方法，但如果没有写访问权限控制符，默认是包权限。因此A错。abstract表抽象，不能修饰变量，因此C错。abstract和final不能同时方法或类，因此D错。static表静态属性，final修饰方法表方法不可重写，B选项声明合法。
补充：
普通类中方法和属性的默认访问权限是default，但不能显示的写default。
抽象类的方法和属性的默认访问权限，在jdk1.7中是protected，在jdk1.8中是default。jdk1.8中这样做是为了让抽象类与其实现类必须在同一个包中。
接口的方法和属性的默认访问权限，是public。
普通类与抽象类中的方法和属性，不能使用default修饰。接口中的方法，可以用default修饰，表示默认方法，且该方法必须有实现体。

2.下面哪一个是正确的输出结果（）

class Foo {
    final int i;
    int j;
    public void doSomething() {
        System.out.println(++j + i);
    }
}

A 0
B 1
C 2
D 不能执行，因为编译有错

答案：D
笔记：
final修饰的成员在使用前必须初始化。
再看下面的例子：

public static void main(String[] args){
    for(int i=0;i<10;i++){
        final int a = i;
        System.out.print(a+" ");
    }
}

我们知道被final修饰的变量只能赋值一次，那么上面的例子会出现编译问题吗。不会，因为遍历a的作用于只在花括号之间，每轮循环结束，变量a就被回收了。也就是说每轮循环的变量a都是不一样的。

六、基本数据类型的自动转换与强制转换

1.（多选题）Java类Demo中存在方法func1、func2、func3和func4，请问该方法中，哪些是不合法的定义( )

public class Demo{
    float func1(){
        int i=1;
        return;
    }
    float func2(){
        short i=2;
        return i;
    }
    float func3(){
        long i=3;
        return i;
    }
    float func4(){
        double i=4;
        return i;
    }
}

A. func1
B. func2
C. func3
D. func4

答案：AD
笔记：
数据类型的转换，分为自动转换和强制转换。
数据类型从大到小需要强制转换，必须在代码中声明，由小到大不需要，会自动转换。
不同类型数据间的优先关系如下：byte、short、char < int < long

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

A. 语句1
B. 语句2
C. 语句3
D. 语句4

答案：ACD
笔记：
byte、short、char类型的任意两个数据想要进行运算操作，都会先转换成int类型，再进行运算操作。final修饰的变量例外。
对于A，当执行b1+b2，b1和b2会先转换成int类型，再进行加运算，再把结果赋给byte类型的b3，就会出现数据类型由大到小，从而出现编译错误。故A错。
对于B，当执行b4+b5，由于b4和b5都是final类型的，因此不会自动转换成int类型，所以和的类型视左边变量类型而定，故B对。
对于C，当执行b1+b4，虽然b4是final类型，不会自动转换成int类型，但是b1会转化成int类型，故和的类型为int类型，因此由于缺少强制转换，故C错。
对于D，同C一个道理，故D错。

3.下面有关java基本类型的默认值和取值范围，说法错误的是（）
A 字节型的类型默认值是0，取值范围是-2^7—2^7-1
B boolean类型默认值是false，取值范围是true\false
C 字符型类型默认是0，取值范围是-2^15 —2^15-1
D long类型默认是0，取值范围是-2^63—2^63-1

答案：B
笔记：

七、原码反码补码

1.经过强制类型转换以后，变量a，b的值分别为多少（）

short a = 128;
byte b = (byte)a;

A. 128 127
B. 128 -128
C. 128 128
D. 编译错误

答案：B
笔记：
一个short变量占2个字节，即16位，一个byte变量占1个字节，即8位。
a的二进制表示为：00000000 10000000，把a强制转换成byte类型再赋给b，因此高8位被截掉，剩下低8位，故b的二进制表示为:10000000。原码10000000表示的是-0，计算机中使用的是补码，原码10000000对应的补码在计算机中表示的是-128。

2.变量a是一个64位有符号的整数，初始值用16进制表示为：0x 7FFFFFFF FFFFFFFF，变量b是一个64位有符号的整数，初始值用16进制表示为：0x 80000000 00000000，则a+b的结果用10进制表示为（）
A. 1
B. -1
C. 2^63+2^62+…+2^2+2^1+2^0
D. -(2^63+2^62+…+2^2+2^1+2^0)

答案：B
笔记：
a+b，得到的结果的16进制表示为0x FFFFFFFF FFFFFFFF,这是计算机中表示的方式，即反码的表示，负数的反码等于原码(除符号位外的其他位)取反+1，由此可得原码为0x 10000000 00000001，其10进制表示为-1，故答案选B。

3.变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（）
A 1
B -(2^62+2^61+2^60+1)
C 2^62+2^61+2^60+1
D 2^59+(2^55+2^54+…+2^2+2^1+2^0)

答案：C
笔记：
0Xf000000000000000补码为1111000000000000000000000000000000000000000000000000000000000000
0x7FFFFFFFFFFFFFFF补码为0111111111111111111111111111111111111111111111111111111111111111
a-b=a+(-b)=
1111000000000000000000000000000000000000000000000000000000000000+
1000000000000000000000000000000000000000000000000000000000000001=
10111000000000000000000000000000000000000000000000000000000000001(高位溢出舍去)
则结果为
0111000000000000000000000000000000000000000000000000000000000001=
2^62+2^61+2^60+1
其中利用到了~n=-n-1这个公式。

4.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果（）

int i = 5;
int j = 10;
System.out.println(i+~j);

A. 15
B. -5
C. -6
D. 编译错误

答案：C
笔记：
~是位运算符号，表示取反。有个公式，-n-1=~n。因此i+~j=i+(-j-1)=5-10-1=-6。
或者这么做：
先计算出j在计算机中的表示方式，即j的补码，从而算出j的补码取反，再求5的补码，再相加（在计算机中都是以补码的进行操作），再转换成原码，从而转换成10进制表示。
10是正数，因此反码等于补码为00001010，取反得到11110101，5的补码为00000101，
01110101+
10000101=
11111010，这是反码表示，其对应的原码为10000110，转换成10进制，即-6。
ps：负数的补码时：符号位位1，其余各位求反，末位加1。

八、编码转码

1.下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换（）

byte[] src,dst;

A dst=String.fromBytes(src，”GBK”).getBytes(“UTF-8”)
B dst=new String(src，”GBK”).getBytes(“UTF-8”)
C dst=new String(“GBK”，src).getBytes()
D dst=String.encode(String.decode(src，”GBK”))，”UTF-8” )

答案：B
笔记：
先用new String(src,”GBK”)解码得到字符串，再用getBytes(“UTF-8”)得到UTF8编码字节数组。
String(byte[] b,Charset charset)：通过使用指定的charset解码指定的byte数组，构造一个新的String。
还有一种情形是new String(str.getBytes(“gbk”),”utf-8”);先通过getBytes方法得到gbk编码字节数组，再通过new String(bytes,”utf-8”)解码得到字符串。

九、import相关问题

1.有一个源代码，只包含import java.util.*，这是一个import语句，下面叙述正确的是（）
A. 只能写在源代码的第一句
B. 可以访问java/util目录下及其子目录下的所有类
C. 能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
D. 编译错误

答案：C
笔记：
导入包，只能访问该包目录下的类，而不包括其子目录中的类。
package语句必须写在第一行（忽略注释行），import语句写在package语句之后，类的定义之前。

十、陷阱之有参构造函数

1.以下输出的结果为（）

class Base{
    public Base(String s){
        System.out.println("B");
    }
}
public class X extends Base{
    public X(String s){
        System.out.println("D");
    }
    public static void main(String args[]){
        new X("C");
    }
}

A. BD
B. DB
C. C
D. 编译错误

答案：D
笔记：
当父类只有有参构造函数而没定义无参构造函数的时候，要特别小心。子类必须显式调用父类的构造方法，否则，编译将不能通过。如果父类中定义了无参构造函数，子类会默认调用父类的无参构造函数。

十一、JVM相关问题

1.对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRadio=3，其最小内存值和Survivor区总大小分别是（）
A. 5120m，1024m
B. 5120m，2048m
C. 10240m，1024m
D. 10240m，2048m

答案：D
笔记：
-Xms：初始堆大小
-Xmx：最大堆大小
-Xmn：年轻代大小
-Xss：每个线程的堆栈大小
-XXSurvivorRadio：年轻代中Eden区与Survivor区的大小比值。
-XX：NewRatio：设置年轻代与年老代的比值
Survivor区有两个（又称为from区和to区），因此一个Survivor区占总的年轻代内存的五分之一。

2.下列哪项不属于jdk1.6垃圾收集器（）
A. Serial收集器
B. parNew收集器
C. CMS收集器
D. G1收集器

答案：D
笔记：

3.（多选题）以下哪些jvm的垃圾回收方式采用的是复制算法回收 1/1
A. 新生代串行收集器
B. 老年代串行收集器
C. 新生代并行回收收集器
D. 老年代并行回收收集器
E. cms收集器

答案：AC
笔记：
新生代采用复制算法，老年代采用标记-整理或标记-清除算法。
MS表示 mark sweep，即标记-清除，
MC表示 mark compression，即标记-压缩，
因此，CMS表示Concurrent Mark Sweep，即多线程标记-清除。
G1收集器比较特殊，整体上是基于标记-整理，局部采用复制。

4.下列Java代码中的变量a、b、c分别在内存的__存储区存放。

class A {
    private String a = “aa”;
    public boolean methodB() {
        String b = “bb”;
        final String c = “cc”;
    }
}

A 堆区、堆区、堆区
B 堆区、栈区、堆区
C 堆区、栈区、栈区
D 堆区、堆区、栈区
E 静态区、栈区、堆区
F 静态区、栈区、栈区

答案：C
笔记：
a是类中的成员变量的引用，存放在堆中，b和c都是方法中的局部变量的引用，存在于栈中。

5.下面输出顺序顺序的是（）

class B extends Object{
    static{
        System.out.println("Load B");
    }
    public B(){
        System.out.println("Create B");
    }
}
class A extends B{
    static{
        System.out.println("Load A");
    }
    public A(){
        System.out.println("Create A");
    }
}

public class Testclass{
    public static void main(String[] args){
        new A();
    }
}

A. Load B ->Create B->Load A -> Create A
B. Load B -> Load A ->Create B ->Create A
C. Load B -> Create B-> Create A -> Load A
D. Create B ->Create A ->Load B ->Load A

答案：B
笔记：
类的加载顺序：
1. 初始化父类中的静态成员变量和静态代码块 ；
2. 初始化子类中的静态成员变量和静态代码块 ；
3. 初始化父类的普通成员变量和代码块，再执行父类的构造方法；
4. 初始化子类的普通成员变量和代码块，再执行子类的构造方法；

6.下面对JVM叙述不正确的是：（）
A JVM的全称是Java Virtual Machine
B JVM是一种计算机硬件技术，它是Java程序的运行平台
C JVM是在计算机硬件系统上用软件实现的一台假想机
D Java程序在执行时．JVM把Java字节码解释成机器码

答案：B
笔记：
JVM即Java Virtual Machine，即Java虚拟机，是在现有的平台如windows、linux上运行的一个软件，虚拟出一台接口统一的计算机，实现java语言的跨平台特性。
Java虚拟机是一颗可执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。Java被设计称允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变成可能，因为它知道底层硬件平台的指令长度和其他特性。

7.下面有关JVM内存，说法错误的是？（）
A 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B 虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C 方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据，是线程隔离的
D 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

答案：C
笔记：
方法区在JVM中也是一个非常重要的区域，它与堆一样，是被线程共享的区域。在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

8.以下代码的输出结果是（）

public class B {
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static {
        System.out.println("静态块");
    }
    public static void main(String[] args) {
        B t = new B();
    }
}

A 静态块 构造块 构造块 构造块
B 构造块 静态块 构造块 构造块
C 构造块 构造块 静态块 构造块
D 构造块 构造块 构造块 静态块

答案：C
笔记：
开始时JVM加载B.class，先执行静态成员的声明，再执行main方法。另外，每一次实例化对象时，先执行构造块，再执行构造函数块。

9.When is the text “Hi there”displayed?（）

public class StaticTest
{
    static
    {
        System.out.println(“Hi there”);
    }

    public void print()
    {
        System.out.println(“Hello”);
    }

    public static void main(String args[])
    {
        StaticTest st1 = new StaticTest();
        st1.print();
        StaticTest st2 = new StaticTest();
        st2.print();
    }
}

A Never.
B Each time a new object of type StaticTest is created.
C Once when the class is loaded into the Java virtual machine.
D Only when the main() method is executed.

答案：C
笔记：
被static修饰的属性或方法，仅在类第一次加载进JVM时执行。

10.What will be printed when you execute the following code?

class C {
    C() {
        System.out.print("C");
    }
}

class A {
    C c = new C();

    A() {
        this("A");
        System.out.print("A");
    }

    A(String s) {
        System.out.print(s);
    }
}

class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }

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

A BB
B CBB
C BAB
D None of the above

答案：B
笔记：
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，再执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，再执行子类的构造方法；
其中，super(“B”); 表示调用父类的构造方法，不调用父类的无参构造函数。

11.下面有关java classloader说法正确的是（）？
A ClassLoader就是用来动态加载class文件到内存当中用的
B JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关
C ClassLoader使用的是双亲委托模型来搜索类的
D Java默认提供的三个ClassLoader是Boostrap ClassLoader，Extension ClassLoader，Application ClassLoader

答案：ACD
笔记：
from牛客网用户“早起吃虫啦”：

JDK中提供了三个ClassLoader，根据层级从高到低为：
Bootstrap ClassLoader，主要加载JVM自身工作需要的类。
Extension ClassLoader，主要加载%JAVA_HOME%\lib\ext目录下的库类。
Application ClassLoader，主要加载Classpath指定的库类，一般情况下这是程序中的默认类加载器，也是ClassLoader.getSystemClassLoader() 的返回值。（这里的Classpath默认指的是环境变量中配置的Classpath，但是可以在执行Java命令的时候使用-cp 参数来修改当前程序使用的Classpath）
JVM加载类的实现方式，我们称为 双亲委托模型：
如果一个类加载器收到了类加载的请求，他首先不会自己去尝试加载这个类，而是把这个请求委托给自己的父加载器，每一层的类加载器都是如此，因此所有的类加载请求最终都应该传送到顶层的Bootstrap ClassLoader中，只有当父加载器反馈自己无法完成加载请求时，子加载器才会尝试自己加载。
双亲委托模型的重要用途是为了解决类载入过程中的安全性问题。
假设有一个开发者自己编写了一个名为Java.lang.Object的类，想借此欺骗JVM。现在他要使用自定义ClassLoader来加载自己编写的java.lang.Object类。然而幸运的是，双亲委托模型不会让他成功。因为JVM会优先在Bootstrap ClassLoader的路径下找到java.lang.Object类，并载入它。

from牛客网用户“大萝卜小萝卜”：

1. 什么是类加载器？
   把类加载的过程放到Java虚拟机外部去实现，让应用程序决定如何去获取所需要的类。实现这个动作的代码模块称为“类加载器”。
2. 有哪些类加载器，分别加载哪些类
   类加载器按照层次，从顶层到底层，分为以下三种：
   (1)启动类加载器 : 它用来加载 Java 的核心库，比如String、System这些类
   (2)扩展类加载器 : 它用来加载 Java 的扩展库。
   (3) 应用程序类加载器 : 负责加载用户类路径上所指定的类库，一般来说，Java 应用的类都是由它来完成加载的。
3. 双亲委派模型
   我们应用程序都是由以上三种类加载器互相配合进行加载的，还可以加入自己定义的类加载器。称为 类加载器的双亲委派模型 ，这里类加载器之间的父子关系一般不会以继承的关系来实现，而是都使用 组合关系 来复用父加载器的。
4. 双亲委托模型的工作原理
   是当一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法加载这个加载请求的时候，子加载器才会尝试自己去加载。
5. 使用双亲委派模型好处？（原因）
   第一：可以避免重复加载，当父亲已经加载了该类的时候，子类不需要再次加载。
   第二：考虑到安全因素，如果不使用这种委托模式，那我们就可以随时使用自定义的String来动态替代java核心api中定义类型，这样会存在非常大的安全隐患，而双亲委托的方式，就可以避免这种情况，因为String已经在启动时被加载，所以用户自定义类是无法加载一个自定义的类装载器。

十二、网络编程

1.关于Socket通信编程，以下描述错误的是：（ ）
A 服务器端通过new ServerSocket()创建TCP连接对象
B 服务器端通过TCP连接对象调用accept()方法创建通信的Socket对象
C 客户端通过new Socket()方法创建通信的Socket对象
D 客户端通过new ServerSocket()创建TCP连接对象

答案：D
笔记：
服务器端通过new ServerSocket()创建TCP连接对象，通过TCP连接对象调用accept()方法创建通信的Socket对象。
客户端通过new Socket()方法创建通信的Socket对象

十三、泛型

1.以下说法错误的是（）
A 虚拟机中没有泛型，只有普通类和普通方法
B 所有泛型类的类型参数在编译时都会被擦除
C 创建泛型对象时请指明类型，让编译器尽早的做参数检查
D 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型

答案：D
笔记：
虚拟机中没有泛型，只有普通类和普通方法；所有泛型类的类型参数在编译时都会被擦除；创建泛型对象的时候，一定要指出类型变量T的具体类型。争取让编译器检查出错误，而不是留给JVM运行的时候抛出类不匹配的异常。
通过反射可以获取获取List中T的实际类型。

2.（多选题）Which four statements are true ?（）
class A {}
class B extends A {}
class C extends A {}
class D extends B {}
A. The type Listis assignable to List.
B. The type Listis assignable to List.
C. The type List