方法覆盖（Override）中的一些问题 2

假如有100个类，分别为Sub1，Sub2…Sub100，它们的一个共同行为是写字，除了Sub1类用脚写字外，其余的类都用手写字。可以抽象出一个父类Base，它有一个表示写字的方法write()，那么这个方法到底如何实现呢？从尽可能提高代码可重用性的角度看，write()方法应该采用适用于大多数子类的实现方式，这样就可以避免在大多数子类中重复定义write()方法。因此Base类的write()方法的定义如下：

public void write(){ //Base类的write()方法

//用手写字

…

}

由于Sub1类的写字的实现方式与Base类不一样，因此在Sub1类中必须重新定义write()方法。

public void write(){ //Sub1类的write()方法

//用脚写字

…

}

如果在子类中定义的一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。

覆盖方法必须满足多种约束，下面分别介绍。

（1）子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致。例如以下代码将导致编译错误。

public class Base {

public void method() {…}

}

public class Sub extends Base{

public int method() { //编译错误，返回类型不一致

return 0;

}

}

Java编译器首先判断Sub类的method()方法与Base类的method()方法的参数签名，由于两者一致，因此Java编译器认为Sub类的method()方法试图覆盖父类的方法，既然如此，Sub类的method()方法就必须和被覆盖的方法具有相同的返回类型。

以下代码中子类覆盖了父类的一个方法，然后又定义了一个重载方法，这是合法的。

public class Base {

public void method() {…}

}

public class Sub extends Base {

public void method(){…} //覆盖Base类的method()方法

public int method(int a) { //重载method()方法

return 0;

}

}

（2）子类方法不能缩小父类方法的访问权限。例如以下代码中子类的method()方法是私有的，父类的method()方法是公共的，子类缩小了父类方法的访问权限，这是无效的方法覆盖，将导致编译错误。

public class Base {

public void method() {…}

}

public class Sub extends Base {

private void method() {…} //编译错误，子类方法缩小了父类方法的访问权限

}

为什么子类方法不允许缩小父类方法的访问权限呢？这是因为假如没有这个限制，将会与Java语言的多态机制发生冲突。例如对于以下代码：

Base base=new Sub(); //base变量被定义为Base类型，但引用Sub类的实例

base.method();

Java编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用base变量所引用的Sub实例的method()方法，如果这个方法为private类型，Java虚拟机就无法访问它。所以为了避免这样的矛盾，Java语言不允许子类方法缩小父类中被覆盖方法的访问权限。本章第6.6节（多态）对多态做了进一步的阐述。

（3）子类方法不能抛出比父类方法更多的异常，关于异常的概念参见第9章（异常处理）。子类方法抛出的异常必须和父类方法抛出的异常相同，或者子类方法抛出的异常类是父类方法抛出的异常类的子类。

例如，假设异常类ExceptionSub1和ExceptionSub2是ExceptionBase类的子类，则以下的代码是合法的：

public class Base {

void method()throws ExceptionBase{}

}

public class Sub1 extends Base {

void method()throws ExceptionSub1{}

}

public class Sub2 extends Base {

void method()throws ExceptionSub1,ExceptionSub2{}

}

public class Sub3 extends Base {

void method()throws ExceptionBase{}

}

以下代码不合法：

public class Base {

void method() throws ExceptionSub1{ }

}

public class Sub1 extends Base {

void method()throws ExceptionBase {} //编译出错

}

public class Sub2 extends Base {

void method()throws ExceptionSub1,ExceptionSub2 {} //编译出错

}

为什么子类方法不允许抛出比父类方法更多的异常呢？这是因为假如没有这个限制，将会与Java语言的多态机制发生冲突。例如对于以下代码：

Base base=new Sub2(); //base变量被定义为Base类型，但引用Sub2类的实例

try{

base.method();

}catch(ExceptionSub1 e){ … } //仅仅捕获ExceptionSub1异常

Java编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用base变量所引用的Sub2实例的method()方法。假如Sub2实例的method()方法抛出ExceptionSub2异常，由于该异常没有被捕获，将导致程序异常终止。

（4）方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间。在同一个类中方法只能被重载，不能被覆盖。

（5）父类的静态方法不能被子类覆盖为非静态方法。例如以下的代码将导致编译错误：

public class Base {

public static void method() { }

}

public class Sub extends Base {

public void method() { } //编译出错

}

（6）子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法。在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束：方法的参数签名一致，返回类型一致，不能缩小父类方法的访问权限，不能抛出更多的异常。例如以下代码是合法的：

public class Base {

static int method(int a) throws BaseException{ return 0; }

}

public class Sub extends Base{

public static int method(int a) throws SubException { return 0; }

}

子类隐藏父类的静态方法和子类覆盖父类的实例方法，这两者的区别在于：运行时，Java虚拟机把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。下面举例来解释这一区别。在例程6-1中，Base类和它的子类即Sub类中都定义了实例方法method()和静态方法staticMethod()。

例程6-1 Sub.java

package hidestatic;

class Base{

void method(){ //实例方法

System.out.println("method of Base");

}

static void staticMethod(){ //静态方法

System.out.println("static method of Base");

}

}

public class Sub extends Base{

void method(){ //覆盖父类的实例方法method()

System.out.println("method of Sub");

}

static void staticMethod(){ //隐藏父类的静态方法staticMethod()

System.out.println("static method of Sub");

}

public static void main(String args[]){

Base sub1=new Sub(); //sub1变量被声明为Base类型，引用Sub实例

sub1.method(); //打印 method of Sub

sub1.staticMethod(); //打印 static method of Base

Sub sub2=new Sub(); //sub2变量被声明为Sub类型，引用Sub实例

sub2.method(); //打印 method of Sub

sub2.staticMethod(); //打印 static method of Sub

}

}

运行Sub类的main()方法，程序将输出：

method of Sub

static method of Base

method of Sub

static method of Sub

引用变量sub1和sub2都引用Sub类的实例，Java虚拟机在执行sub1.method()和sub2.method()时，都调用Sub实例的method()方法，此时父类Base的实例方法method()被子类覆盖。

引用变量sub1被声明为Base类型，Java虚拟机在执行sub1. staticMethod()时，调用Base类的staticMethod()方法，可见父类Base的静态方法staticMehtod()不能被子类覆盖。

引用变量sub2被声明为Sub类型，Java虚拟机在执行sub2. staticMethod()时，调用Sub类的staticMethod()方法，Base类的staticMehtod()方法被Sub类的staticMehtod()方法隐藏。

（7）父类的非静态方法不能被子类覆盖为静态方法。例如以下代码是不合法的：

public class Base {

void method() { }

}

public class Sub extends Base {

static void method() { } //编译出错

}

（8）父类的私有方法不能被子类覆盖。例如在例程6-2中，子类Sub中定义了一个和父类Base中的方法同名、参数签名和返回类型一致，但访问权限不一致的方法showMe()，父类中showMe()的访问权限为private，而子类中showMe()的访问权限为public。尽管这在形式上和覆盖很相似，但Java虚拟机对此有不同的处理机制。子类方法覆盖父类方法的前提是，子类必须能继承父类的特定方法，由于Base类的private类型的showMe()方法不能被Sub类继承，因此Base类的showMe()方法和Sub类的showMe()方法之间并没有覆盖关系。

例程6-2 Sub.java

package privatetest;

class Base {

private String showMe() {

return "Base";

}

public void print(){

System.out.println(showMe()); //到底调用Base类的showMe()还是Sub类的showMe()?

}

}

public class Sub extends Base {

public String showMe(){

return "Sub";

}

public static void main(String args[]){

Sub sub=new Sub();

sub.print();

}

}

执行以上Sub类的main()方法，会打印出结果“Base”，这是因为print()方法在Base类中定义，因此print()方法会调用在Base类中定义的private类型的showMe()方法。

但是如果把Base类的showMe()方法改为public类型，其他代码不变：

public class Base {

public String showMe() {

return "Base";

}

…

}

再执行以上Sub类的main()方法的代码，会打印出结果“Sub”，这是因为此时Sub类的showMe()方法覆盖了Base类的showMe()方法。因此尽管print()方法在Base类中定义，Java虚拟机还是会调用当前Sub实例的showMe()方法。

（9）父类的抽象方法可以被子类通过两种途径覆盖：一是子类实现父类的抽象方法；二是子类重新声明父类的抽象方法。例如以下代码合法：

public abstract class Base {

abstract void method1();

abstract void method2();

}

public abstract class Sub extends Base {

public void method1(){…} //实现method1()方法，并且扩大访问权限

public abstract void method2(); //重新声明method2()方法，仅仅扩大访问权限，但不实现

Tips

狭义的理解，覆盖仅指子类覆盖父类的具体方法，即非抽象方法，在父类中提供了方法的默认实现方式，而子类采用不同的实现方式。在本书中，为了叙述方便，把子类实现父类的抽象方法也看做方法覆盖。

例如以下代码不合法：

public abstract class Base {

abstract void method1();

abstract void method2();

}

public abstract class Sub extends Base {

private void method1(){…} //编译出错，不能缩小访问权限

private abstract void method2(); //编译出错，不能缩小访问权限

}

（10）父类的非抽象方法可以被覆盖为抽象方法。例如以下代码合法：

public class Base {

void method(){ }

}

public abstract class Sub extends Base {

public abstract void method(); //合法

}

图6-2 Sub类继承Base类

在本书提供的UML类框图中，在子类中只会显示子类特有的方法及覆盖父类的方法，而不会显示直接从父类中继承的方法。例如，图6-2表明Base类是抽象类（Base名字用斜体字表示），method1()为抽象方法（method1名字用斜体字表示），method2()和method3()为具体方法。Sub类是Base类的子类，Sub类实现了Base类的method1()方法，覆盖了Base类的method2()方法，直接继承Base类的method3()方法，此外Sub类还有自己的method4()方法。