那些猥琐的Java笔试题集锦(持续更新)

做个备忘记录下一些笔试题考察的零散的知识点吧.

Problem1:考察String的replace方法

What will be the output of the following statement sequence?String s="I like tea (if the tea is not too hot) but I hate coffee"; s.replace("tea", "beer"); System.out.println(s); A、Real programmers drink coffee not tea ;-)B、I like tea (if the tea is not too hot) but I hate coffeeC、I like beer(if the beer is not too hot) but I hate coffeeD、I like beer(if the tea is not too hot) but I hate coffee

答案是B. 

请注意replace方法会返回一个全新的被替换后的字符串. 仔细看, 这里只是s.replace()调用了一下, s并没有被改变, 如果希望是C的输出, 应该写为 s = s.replace("tea", "beer")

Problem2:考察获取集合长度的方法

Select the correct output for the next code:01: import java.util.ArrayList; 02:  03: public class Java { 04:  05:     public static void main(String[] args) { 06:         07:         ArrayList objects = new ArrayList(); 08:          09:         for(int i=0 ; i<5; i++){ 10:             objects.add(i); 11:         } 12:          13:         for(int j=0; j<objects.length(); ++j) { 14:             System.out.println(objects.get(j));15:             j++; 16:         } 17:          18:     } 19: } 

A. Compile error                       B. 1 3 5                   C. 0 1 2 3 4               D. 0  2  4

答案是A.

 还在想输出么? ArrayList根本没有 length() 方法, 是size(), size(), size() !!!(重要的事情说三遍). 有length()的是String! 有length的是数组!  

Problem3:考察上下转型

interface Foo {}   class Alpha implements Foo { }   class Beta extends Alpha {}      class Delta extends Beta {       public static void main( String[] args) {           Beta x = new Beta();           // insert code here      }   }    下列哪个选项是<strong>错误</strong>的:  A. Beta b = (Beta)(Alpha)x;  B. Foo f1= (Alpha)x;  C. Foo f2= (Delta)x;  D. Alpha a = x;

答案是C.

Java中的转型, 需要遵守两个原则:

1) 绝对不能使用子类的句柄指向父类的实例(然而父类句柄却可以指向子类实体, 这是向上转型).  

2) 向下转型(将指向子类实体的父类句柄)一定要加强制转换的语法(类型), 而且两种类型必须本来就能够强转 

main方法第一行定义了一个Beta对象x,  C选项(Delta)x 相当于 Delta d = (Delta)x 使用一个Delta(子类)句柄指向一个Beta(父类)实体, 违反第一点.

Problem4:考察函数签名的匹配

求下面代码的输出

public class Test{public static void go(Long a ){System.out.println("Long");}public static void go (Short n){System.out.println("Short");}public static void go (int n ){System.out.println("int ");}public static void  main (String [] args){short y = 6;long z = 7;go(y);go(z);}}

答案是:

int

Long
调用重载的方法, 在寻找签名匹配的函数的时候, 如果不能完全匹配, 就寻找最精确的匹配.先匹配基本数据类型, 再匹配包装类, 而且只能向上匹配, 不能向下匹配(只能小匹配大, 不能大匹配小). 

对go(y), y是short类型, 由于我们并没有重载基本数据类型的shor(Short是包装类), 因此不能找到完美匹配的签名. 开始寻找最精确的匹配, 先从基本数据类型开始找, 这里重载了int类型的go, 由于short比int小, 可以向上匹配到go(int)

对于go(z), z是long类型, 同样我们并没有重载基本数据类型的long, 因此不能找到完美匹配. 开始寻找最精确匹配, 先从基本数据类型开始找, 这里同样重载了go(int), 但是由于long大于int, 不能向下匹配, 再看包装类, 最终匹配到了go(Long)

Problem 5: 考察基本数据类型大小与默认值

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

答案是：

Java中采用的是Unicode进行文本编码，一个字符占2个byte，即16个位，且没有负值。故char的取值范围为2^16 -1

Problem 6:考察基本数据类型之间的转换

 Which lines of the following will produce an error?1. byte a1 = 2, a2 = 4, a3;2. short s = 16;3. a2 = s;4. a3 = a1 * a2; 

答案是：

第3,4行， Java中类型的转换， 小转大是隐式转换， 大转小必须是显式强制类型转换， 大小次序为 byte<char<short<int<long<float<double 。

另外， java中对于char， byte， short参与的运算， 其结果会自动转型为int， 因此第四行相当于 int 转 byte， 大转小没有显式强制类型转换也是错的。

Problem 7: 考察类型的隐式转换与==号的比较(这种题目真是猥琐到令人发指)

下列 java 程序输出结果为______。int i=0;Integer j = new Integer(0);System.out.println(i==j);System.out.println(j.equals(i));

答案是：

两个True. 你以为Integer是对象，所以比较的是地址与值?那你就错了! Java在比较int 与 Integer时， Integer会自动拆箱为int， 因此==比较的是值，所以为true。

补充： 两个Integer比较的才是地址，且 Integer a =6; Integer b = Integer.valueOf(6); 比较返回的是true， 这里仍然返回地址， 但是比较的是缓存的同一个对象，道理类似用同一个产量初始化String。

Problem 8: 考察继承过程中方法的可见性约束

 已知如下类定义：class Base {   public Base (){  //...  }   public Base ( int m ){  //...  }   public void fun( int n ){  //...  } }  public class Child extends Base{   // member methods  }如下哪句可以正确地加入子类中？A. private void fun( int n ){ //...}B. void fun ( int n ){ //... }C. protected void fun ( int n ) { //... }D. public void fun ( int n ) { //... }

答案是：

D。 在继承的过程中， 子类如果重写父类的方法，其可见性必须 >= 父类的可见性， 题中父类可见性为public，子类重写只能是public。

Problem9： 考察多态的构造函数调用

class Person {    String name = "No name";    public Person(String nm) {        name = nm;    }}class Employee extends Person {    String empID = "0000";    public Employee(String id) {        empID = id;    }}public class Test {    public static void main(String args[]) {        Employee e = new Employee("123");        System.out.println(e.empID);    }} 对文件名为Test.java的java代码描述正确的是()A.输出：0000B.输出：123C.编译报错D.输出：No name

答案是：

C。子类会默认调用父类的无参构造函数，但是这里父类只定义了带参数的构造函数(一旦定义了我们自己的构造方法，缺省的无参构造函数被屏蔽)， 并没有定义无参构造函数，因此需要在子类的构造函数中显式调用父类的带参数构造函数 super(id)， 否则会报错。

Problem10: 考察ArrayList遍历删除的方法

list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（） Iterator it = list.iterator();int index = 0;while (it.hasNext()){    Object obj = it.next();    if (needDelete(obj))  //needDelete返回boolean，决定是否要删除    {        //todo delete    }    index ++;}A. it.remove();B.list.remove(obj);C.list.remove(index);D.list.remove(obj,index);

答案是：A. 如果我们使用的是迭代器来遍历ArrayList的话，我们在遍历的过程中的删除也必须是使用迭代器的remove方法，否则会抛出ConcurrentModificationException。

另外，在for循环中调用list.remove()这种方法虽然不会抛出错误，但是并不能正确删除。不信可以试一下下面的代码，原因可能要到源码去看，时间关系不做深入。

import java.util.*;class Solution {    public static void main(String[] args){        LinkedList<Integer> ali = new LinkedList<Integer>();        for(int i = 0; i < 15; i++){            ali.add(i);        }        System.out.println(ali);        Iterator<Integer> it = ali.iterator();        while(it.hasNext()){            Integer g = it.next();            ali.remove();        }        System.out.println(ali);        }}