7 易错题分析

分析一下作业中写错或者易错的题。


$No.1$ 下面程序的执行结果是______。

public class Test7 {
    public static void main(String[] args){
        new B().display();
    }
}
class A{
    public void draw() {
        System.out.print("Draw A.");
    }
    public void display() {
        draw();
        System.out.print("Display A.");
    }
}
class B extends A{
    public void draw() {
        System.out.print("Draw B.");
    }
    public void display() {
        super.display();  
        System.out.print("Display B.");
    }
}
A. Draw A.Display A.Display B. B. Draw A.Display B.Display A.
C. Draw B.Display A.Display B. D. Draw B.Display B.Display A.

解析

答案 C
这道题容易误选 A。关键在于理解子类B是如何调用父类A内被覆盖的方法的。Bdisplay()方法中调用super.display()不是进入类A中再调用A的方法,而是在B类中重新发现父类被覆盖的方法。所以也就不难理解,draw()方法打印的是"Draw B."了。


$No.2$ 给定下列程序,下面说法正确的是______。

public class Test2_16 {
    public void m1() throws IOException{
        try {
            throw new IOException();
        }
        catch (IOException e){

        }
    }
    public void m2(){
        m1();
    }
}
A. 因m1方法里已经捕获了异常,因此m2里调用m1()时不用处理异常,程序编译通过
B. m2或者用throws声明异常,或者在方法体里面用try/catch块去调用m1并捕获异常,否则编译报错
C. m2方法体里面必须用try/catch块去调用m1并捕获异常,否则编译报错
D. m2方法必须用throws声明异常,否则编译报错

解析

答案 B
这道题容易误选 A。诚然,方法m1中抛出的IOException已经被方法内的try/catch块处理了,方法头里写的throws IOException是多余的。但是,正是因为方法头里写了这一个throws IOException,即使m1并不会真的抛出这个异常,调用m1的方法还是得做好收到异常的准备,因为编译器判断是否抛出异常只看你的函数头。


$No.3$ 给定下列程序,下面说法正确的是______。

1
2
3
4
5
6
7
8
public class Test2_17 {
    public void m1() throws RuntimeException{
        throw new RuntimeException();
    }
    public void m2(){
        m1();
    }
}
A. 程序编译通过
B. m2或者用throws声明异常,或者在方法体里面用try/catch块去调用m1并捕获异常,否则编译报错
C. m2方法体里面必须用try/catch块去调用m1并捕获异常,否则编译报错
D. m2方法必须用throws声明异常,否则编译报错

解析

答案 A
这道题和 $No.2$ 很像,容易也选 B。实际上,RuntimeException非必检异常,所以即使抛出了也不需要处理(当然也可以选择处理,如果不处理就扔给 JVM 去做)。上一题的IOException是必检异常,抛出来了不处理编译就会出错。


$No.4$ 下面程序,写出指定语句的输出结果,并解释原因。

public class Test5 {
    public static void main(String... args){
        C o1 = new D();  
        o1.m(1,1);              //(1)
        o1.m(1.0,1.0);          //(2)
        o1.m(1.0f, 1.0f);       //(3)

        D o2 = new D();
        o2.m(1,1);          //(4)
        o2.m(1.0,1.0);          //(5)
        o2.m(1.0f, 1.0f);       //(6)
    }
}

class C{
    public void m(int x, int y) {
        System.out.println("C's m(int,int)");
    }
    public void m(double x, double y) {
        System.out.println("C' m(double,double)");
    }
}

class D extends C{
    public void m(float x, float y) {
        System.out.println("D's m(float,float)");
    }
    public void m(int x, int y)  {
        System.out.println("D's m(int,int)");
    }
}

解析

答案 上面语句的执行结果是:

1
2
3
4
5
6
D's m(int,int)
C' m(double,double)
C' m(double,double)
D's m(int,int)
C' m(double,double)
D's m(float,float)
这一题中 (3) 语句的执行结果可能出人意料。o1是一个引用类型为C,运行时类型为D的引用变量,用(float,float)参数列表调用o1m方法,显然能够在运行时类型D中找到一个完全一样的形参列表,但是 JVM 却并没有调用它。
不是说实例方法具有多态性,方法入口是在运行时绑定的吗?
实例方法确实具有多态性,入口也是在运行时绑定,只不过过程可能和我们想象的有些不一样。我们可能认为, JVM 在运行对于的代码的时候,是只根据传入形参的实际类型来选择调用哪个函数的。实际上,JVM还会兼顾在编译时获取的信息
你看,如果我把C中的两个m方法全都删掉,语句 (3) 在编译时会报错——这说明编译时是会根据o1引用类型去检查相应的方法的。

因此,编译器在编译o1.m(1.0f,1.0f)的时候,也根据形参列表(float,float)去引用类型C里面寻找相应的方法;没有找到完全适合的方法,但是有一个m(double,double)凑合着可以用。编译器告诉JVM:你在运行的时候要找到一个m(double,double)这样的方法并且调用它。JVM 很听话,在运行的时候去找了,但是是根据运行时类型D去找的,恰好看到D继承了C的这个m(double,double),所以就直接调用它了,也不去管什么m(float,float)是不是更合适一点。
上面提出的解释也能很好地说明子类覆盖父类方法时的情况。假设D里面也有一个m(double,double),那么是对父类方法的重写。实际运行m(1.0,1.0)的时候看起来像是 JVM 直接根据形参列表在D里找到了一个m(double,double)方法,实则不然;实际情况应该是编译器找到C里的形参列表为(double,double)的方法,然后告诉 JVM 去找。此时刚好子类覆盖了这个方法,所以看起来像是 JVM 独立寻找得到的结果。