JAVA类与方法·易错题分析

分析一下作业中关于类与方法写错或者易错的题。

$N o .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内被覆盖的方法的。B的display()方法中调用super.display()，不是进入类A中再调用A的方法，而是在B类中重新发现父类被覆盖的方法。所以也就不难理解，draw()方法打印的是"Draw B."了。

$N o .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的方法还是得做好收到异常的准备，因为编译器判断是否抛出异常只看你的函数头。

$N o .3$ 给定下列程序，下面说法正确的是______。

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

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

$N o .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)");
    }
}

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

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)参数列表调用o1的m方法，显然能够在运行时类型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 独立寻找得到的结果。