分析一下作业中关于类与方法写错或者易错的题。
N o . 1 No.1 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
内被覆盖的方法的。B
的display()
方法中调用super.display()
,不是进入类A
中再调用A
的方法,而是在B
类中重新发现父类被覆盖的方法。所以也就不难理解,draw()
方法打印的是"Draw B."
了。
N o . 2 No.2 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
的方法还是得做好收到异常的准备,因为编译器判断是否抛出异常只看你的函数头。
N o . 3 No.3 No.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 No.2 No.2 很像,容易也选 B。实际上,
RuntimeException
是非必检异常,所以即使抛出了也不需要处理(当然也可以选择处理,如果不处理就扔给 JVM 去做)。上一题的IOException
是必检异常,抛出来了不处理编译就会出错。
N o . 4 No.4 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)");}
}
答案 上面语句的执行结果是:
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 独立寻找得到的结果。