Java基础笔试题目记录

记录一些遇到的不错的笔试题

1、

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

答案：true true

解析：
本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上）
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

int a=257;
Integer b=257;
Integer c=257;
Integer b2=57;
Integer c2=57;
System.out.println(a==b);
//System.out.println(a.equals(b));  编译出错，基本型不能调用equals()
System.out.println(b.equals(257.0));
System.out.println(b==c);
System.out.println(b2==c2);

上面的代码的结果因此为 true, false, false, true

2、

下面程序输出结果是__

public class Test {  
    public static void main(String [] args){  
        System.out.println(new B().getValue());  
    }  
    static class A{  
        protected int value;  
        public A(int v) {  
            setValue(v);  
        }  
        public void setValue(int value){  
            this.value = value;  
        }  
        public int getValue(){  
            try{  
                value++;  
                return value;  
            } catch(Exception e){  
                System.out.println(e.toString());  
            } finally {  
                this.setValue(value);  
                System.out.println(value);  
            }             
        }  
    }  
    static class B extends A{  
        public B() {  
            super(5);  
            setValue(getValue() - 3);  
        }  
        public void setValue(int value){  
            super.setValue(2 * value);  
        }  
    }  
}  

答案：22 34 17

解析：
最关键的一点是：super(5) //调用了父类构造器，其中构造函数里面的setValue(value),由于子类有重写，所以调用的是子类的setValue方法

3、

阅读下列程序，选择哪一个是正确的输出结果

class HelloA{
public HelloA()
    {
        System.out.println("I’m A class ");
    }
    static
    {
    System.out.println("static A");
    }
}
public class HelloB extends HelloA{
    public HelloB()
    {
        System.out.println("I’m B class");
    }
    static{
        System.out.println("static B");
    }
    public static void main (String[] args){
        new HelloB();
    }
}

结果：
static A static B I’m A class I’m B class

解析：
该题目中的执行顺序：

   父类的静态变量和静态块赋值（按照声明顺序）

   自身的静态变量和静态块赋值（按照声明顺序）

   父类成员变量和块赋值（按照声明顺序）

   父类构造器赋值

  自身成员变量和块赋值（按照声明顺序）

   自身构造器赋值
类的静态代码块是属于类级别，执行优先级高于普通代码块>构造函数。总结就是：父类的静态代码块（包括静态变量赋值）优先执行，然后执行自身的静态代码块，然后执行父类的普通代码块，再执行父类的构造函数，然后执行自身的普通代码块，再执行自身的构造函数。

4、

关于下面代码片段叙述正确的是（）

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6);

A 、输出结果：13
B 、语句：b6=b4+b5编译出错
C、语句：b3=b1+b2编译出错
D、运行期抛出异常

正确答案C。
解析：
为什么不选择B，是因为b4、b5被final修饰，所以在运算的时候，不会被升级为int类型，而b1和b2在运行的 时候被升级成了int类型，而b3是byte类型，类型不匹配。

5、

以下代码在编译和运行过程中会出现什么情况

public class TestDemo{
    private int count;
    public static void main(String[] args) {
        TestDemo test=new TestDemo(88);
        System.out.println(test.count);
    }
     TestDemo(int a) {
         count=a;
    }
}

A、编译运行通过，输出结果是88
B、编译时错误，count变量定义的是私有变量
C、编译时错误，System.out.println方法被调用时test没有被初始化
D、编译和执行时没有输出结果
正确答案：A
解析：
私有变量外部无法访问，这个外部指的是类的外部，而这里的main方法是在大类TestDemo的内部，所以说是可以访问到的。有如下代码：

public class Demo2 {
    private int count;
    public Demo2(int a){
        count = a;
    }

    public static void main(String[] args) {

        Demo2 d = new Demo2(88);
        System.out.println(d.count);//正常运行，无报错

        P p = new P(88);
        System.out.println(p.count);//此行编译期间报错，私有变量访问不到
    }
}

class P{
    private int count;
    public P(int a){
        count = a;
    }
}

6、

以下程序输出结果是什么？

class TestA {

    public void printValue(){
        System.out.println("Test01");
    }
}

class TestB extends TestA{
    public void printValue(){
        System.out.println("TestB");
    }
}

public class Test01 {

    public static void main(String[] args) {
        TestB b = new TestB();
        b.printValue();
        TestA a = (TestA)b;//类型转换
        a.printValue();
    }
}

输出结果：
TestB
TestB
解析：
这里关键是类型转换那一行，由于b本身的定义是TestB类型，这里没发转成TestA类型，输出仍然是“TestB”