Java面试：单选选择题和判断题

一、单选选择题

１、关于以下application，说法正确的是？

public class test001 {
    static int x = 10;
    static {x += 5;};
    public static void main(String[] args) {  // a
        System.out.println("x = " + x);
    }
    static {x /= 3;};
} // b

A：a行和b行不能通过编译，因为缺少方法名和返回类型
B：编译通过，执行结果是：x=5
C：编译通过，执行结果是：x=3
D：b行不能通过编译，因为只能有一个静态初始化器

解析：考察类加载的初始化问题
参考答案：选Ｂ。

虚拟机在首次加载Java类时，会对静态初始块，静态成员变量，静态方法进行一次初始化。
　　因此静态代码块先于主方法执行，静态代码块之间遵从代码顺序执行。因此：
１）先初始化静态变量x=10 //x=10
２）执行第一个静态代码块，x=x+5 //x=15
３）执行第二哥静态代码块，x=x/3 //x=5
４）执行主方法，输出x=5

２、选项中的哪一行代码可以替换a行位置，而不产生编译错误？

public abstract class test002 {
    public int consInt = 5;
    // ａ行
    public void method(){}
}

Ａ：public abstract void method(int a);
B： consInt = consInt + 5;
C： public int method();
D： public abstract void anotherMethod() {};

解析：
参考答案：选A
A：抽象类可以包含抽象方法，正确。
Ｂ：类中定义成员和方法，不能直
接进行运算，可以卸载代码块{}或者静态代码块中static{}
Ｃ：返回类型不能作为重载的依据
Ｄ：该方法带了方法体{}，但是抽象方法不能包含方法体，所以错误，这个还需要认真看。

3、下面赋值语句中正确的是（）
A：double d = 5.3e12;
B：float f = 11.1;
C：int i = 0.0;
D：Double k = 3;

解析：
参考答案：选A
java中整型默认的是int，浮点默认的是double。
Ｂ：double类型的11.1转为float，是需要强转的，即11.1f，所以错误
Ｃ：double类型的0.0转为int，也是需要强转的，错误
Ｄ：可以把double类型自动装箱为Double，但是不能转化int，错误

4、以下定义一维数组的语句中，正确的是：
A：int a[10];
B：int a[] = new [10];
C：int a[] = new int[5] {1,2,3,4,5};
D：int a[] = {1,2,3,4,5};

解析：
参考答案：选Ｄ
Java一维数组有２种初始化方法：
１）静态初始化：
int array[] = new int[] {1,2,3,4,5};　或
int array[] = {1,2,3,4,5}
２）动态初始化：
int array[] = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;

5、以下程序的输出结果为（）

public class Base {
    public Base(String s) {
        System.out.println("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.println("D");
    }

    public static void main(String[] args) {
        new Derived("C");
    }
}

A：BD
B：D
C：C
D：编译错误

解析：
参考答案：D
　　子类构造方法在调用时必须先调用父类构造器，且必须在第一行就调用，也就是首先要把父类部分的参数和方法构造好，然后再构造子类的参数和方法。
　　如果子类没有显示调用，那么默认调用父类的无参构造器。
　　如果父类包含有参构造器，却没有无参构造器，那么子类必须要显示地调用父类的有参构造器。
所以应该为：

public Derived (String s) {
　　　　　super(s);
        System.out.println("D");
    }

６、下面哪个类未实现或继承Collection接口？
A： HashMap
B： ArrayList
C： Vector
D： HaseSet

解析：
参考答案：选A
集合类主要由２个接口派生：Collection，Map

７、对于文件的描述正确的是（）
A：文本文件是以".txt"为后缀名的文件，其他后缀名的文件是二进制文件。
B：FIle类是Java中对文件进行读写操作的基本类。
C：无论文本文件还是二进制文件，读到文件末尾都会抛出EOFException异常
D：Java中对于文本文件和二进制文件，都可以当做二进制文件进行操作。

解析：
参考答案：D
A：文件分为文本文件和二进制文件，计算机只认识二进制，所以实际上都是二进制的不同解释方式。
B：File类是对文件整体或者文件属性操作的类，例如创建文件、删除文件、查看文件是否存在等功能，但是不能操作文件内容。文件内容是用IO流操作的。
C：当输入过程中意外到达文件或流的末尾时，抛出EOFException异常。正常情况下读取到文件末尾时，返回一个特殊值表示文件读取完成，例如read()返回-1表示文件读取完成。

８、下面有关java hashmap的说法错误的是？
A：HashMap的实例有两个参数影响其性能：“初始容量”和“加载因子”
B：HashMap的实现不是同步的，意味着他不是线程安全的
C：HashMap通过开放地址法解决哈希冲突
D：HashMap中的key-value都是存储在Entry数组中的

解析：
参考答案：C
HashMap是通过链地址法解决哈希冲突的。
１）开放地址法：线性探测再散列、二次探测再散列、再随机探测再散列；
２）再哈希法：换一种哈希函数
３）链地址法：在数组中冲突元素后面拉一条链路，存储重复元素
４）建立一个公共溢出区：建一个标，存放冲突的元素。
　　HashMap底层是数组和链表的结合体。底层是一个线性数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。数组是Entry[]数据，静态内部类。Entry就是数组中的元素，每个Map.Entry就是一个key-value对。

9、执行下列代码的输出结果是（）

public class test005 {
    public static void main(String[] args) {
        int num = 10;
        System.out.println(test(num));
    }

    public static int test(int b) {
        try{
            b += 10;
            b /= 0;
            return b;
        } catch (Exception e) {
            b += 10;
            return b;
        } finally {
            b += 10;
            return b;
        }
    }
}

A：10
B：20
C：30
D：40

解析：
参考答案：D
首先，finally代码块的语句一定会执行！
如果try块中有return语句
１）当finally代码块没有return语句，那么try块中的return语句在返回之前会先将要返回的值保存，之后执行finally中的代码块，最后将保存的返回值返回。即使finally代码块对返回值进行修改，也不影响返回值，因为要返回的值在执行finally代码块之前已经保存了，最终返回的是旧值。所以本地如果finally块中没有return b的话，答案为30。
２）当finally代码块中有return语句时，虽然try块中返回值在执行finally代码块之前被保存了，但是最终执行的是finally代码块中的return语句，try块中的return语句不再执行。所以本题的答案为40。

二、判断题New TNew Tabab

１、在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过。

解析：
参考答案：正确。

２、final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性。

解析：
参考答案：错误。
抽象类：子类继承重写
final修饰的类不可以被继承，因此矛盾。
final修饰的方法不可以被覆盖。
final修饰的变量为常量，只能赋值一次。

3、子类A继承父类B，A a = new A()，执行的先后顺序是：
父类Ｂ静态代码块　－>　父类Ｂ构造函数　－> 父类Ｂ非静态代码块　－> 　子类Ａ静态代码块　－> 　子类Ａ构造函数　－> 　子类Ａ非静态代码块

解析：
参考答案：错误
当实例化子类对象时，首先要加载父类的class文件进内存，静态代码块是随着类的创建而执行，所以父类静态代码块最先被执行。然后子类class文件再被加载，同理第２个是子类Ａ的静态代码块被执行。实例化子类对象，要先调用父类Ｂ的构造方法，而调用父类Ｂ的构造方法之前会先执行父类Ｂ的非静态代码块。所以正确的顺序是：
父类Ｂ静态代码块 －>　子类Ａ静态代码块　－> 父类Ｂ非静态代码块　－> 　父类Ｂ构造函数　－> 子类Ａ非静态代码块 －> 子类Ａ构造函数