方法覆盖(Override)

转载 2016年06月01日 20:37:10

6.3 方法覆盖(Override)

假如有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(); //合法

}


[转载]JAVA-方法覆盖(第3篇)

图6-2 Sub类继承Base类

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

相关文章推荐

java 方法的覆盖(overriding)与重载(override)

java 方法的覆盖(overriding)与重载(override) 转自:方法的覆盖与重载 方法的覆盖 在类继承中,子类可以修改从父类继承来的方法,也就是说子类能创建一个与父类方...

方法的重载(overload)和覆盖(override)

Java中重载(overload)与覆盖(override)的区别

java基础---方法的重载(overload)和覆盖(重写)(override)

重载(overload):对于类的方法(包括从父类中继承的方法),方法名相同,参数列表不同,就称之为函数的重载。重载是一个类中多态性的一种表现。Java的方法重载,就是在类中可以创建多个方法,它们具有...

C#中子类对父类中虚方法的处理有重写(override)和覆盖(new),他们有什么区别?

在子类中用override重写父类中用virtual申明的虚方法时,实例化父类调用该方法,执行时调用的是子类中重写的方法; 如果子类中用new覆盖父类中用virtual申明的虚方法时,实例化父类调用该...

C# 虚方法(virtual)覆盖(override) - 隐藏(new) - 重载

using System; using System.Collections.Generic; using System.Text; using System.Threading; nam...

Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

Overload是重载的意思,Override是覆盖的意思,也就是重写。 重载Overload表示同一个类中可以有多个名称相同的方法,但这些方法的参数列表各不相同(即参数个数或类型不同)。 重写O...

C#中的一些方法修饰关键字virtual override sealed new

对于方法(属性、事件) 1. 如想重写(扩展和修改继承)方法要求有两个     a. 基类必须是virtual     b. 继承类型的同签名方法必须override也就是说基类和继承类都必须同...

C#.NET 虚方法中中的virtual 和override关键字的使用

谈到C#.NET的虚方法就不得不先说一下继承性(inheritance),继承和多态度、封装一起构成面向对象程序设计的三大要素,继承指一个类基于一个已有的类按照需求添加和删除一些功能. 首先,我...

总结virtual override sealed new在方法上的应用

对于方法(属性、事件) 1.       如想重写(扩展和修改继承)方法要求有两个 a.        ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)