方法重载和方法覆盖

时间：2020-12-08 10:59:35 学习方法我要投稿

方法重载和方法覆盖

　　重载与覆盖的区别【一】

　　1、方法的覆盖是子类和父类之间的关系，是垂直关系;方法的重载是同一个类中方法之间的关系，是水平关系。

　　2、覆盖只能由一个方法，或只能由一对方法产生关系;方法的重载是多个方法之间的关系。

　　3、覆盖要求参数列表相同;重载要求参数列表不同。

　　4、覆盖关系中，调用那个方法体，是根据对象的类型(对象对应存储空间类型)来决定;重载关系，是根据调用时的实参表与形参表来选择方法体的。

　　override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

　　1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果;

　　2、覆盖的方法的返回值必须和被覆盖的方法的返回一致;

　　3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类;

　　4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

　　overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

　　1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序(当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int));

　　2、不能通过访问权限、返回类型、抛出的异常进行重载;

　　3、方法的异常类型和数目不会对重载造成影响;

　　4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果

　　class A {

　　protected int method1(int a, int b) { return 0; }

　　}

　　public class B extends A{

　　public int method1(int a, int b) { return 0; } //正确，重写父类方法，可以扩大访问权限

　　//private int method1(int a, int b) { return 0; } //错误，重写父类方法，不能降低了访问权限

　　//private long method1(int a, int b) { return 0; } //错误，重写父类方法，不能改变返回值类型

　　public short method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型

　　private int method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型

　　}

　　方法覆盖(overwrite)与方法重载(overload)详解【二】

　　方法重载(Overload)

　　有时候，类的同一种功能有多种实现方式，到底采用哪种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。

　　public void train(Dog dog){

　　//训练小狗站立、排队、做算术

　　…

　　}

　　public void train(Monkey monkey){

　　//训练小猴敬礼、翻筋斗、骑自行车

　　…

　　}

　　再例如某个类的一个功能是比较两个城市是否相同，一种方式是按两个城市的名字进行比较，另一种方式是按两个城市的名字，以及城市所在国家的名字进行比较。

　　public boolean isSameCity (String city1,String city2){

　　return city1.equals(city2);

　　}

　　public boolean isSameCity(String city1,String city2,String country1,String country2){

　　return isSameCity(city1, city2) && country1.equals(country2);

　　}

　　再例如java.lang.Math类的max()方法能够从两个数字中取出最大值，它有多种实现方式。

　　public static int max(int a,int b)

　　public static int max(long a,long b)

　　public static int max(float a,float b)

　　public static int max(double a,double b)

　　以下程序多次调用Math类的max()方法，运行时，Java虚拟机先判断给定参数的类型，然后决定到底执行哪个max()方法。

　　//参数均为int类型，因此执行max(int a,int b)方法

　　Math.max(1,2);

　　//参数均为float类型，因此执行max(float a,float b)方法

　　Math.max(1.0F, 2.0F);

　　//参数中有一个是double类型，自动把另一个参数2转换为double类型，

　　//执行max(double a,double b)方法

　　Math.max(1.0,2);

　　对于类的方法(包括从父类中继承的方法)，如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。

　　重载方法必须满足以下条件：

　　l 方法名相同。

　　l 方法的参数类型、个数、顺序至少有一项不相同。

　　l 方法的返回类型可以不相同。

　　l 方法的修饰符可以不相同。

　　在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的两个方法，Java虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型、个数和顺序。

　　例如以下Sample类中已经定义了一个amethod()方法。

　　public class Sample{

　　public void amethod(int i, String s){}

　　//加入其他方法

　　}

　　下面哪些方法可以加入到Sample类中，并且保证编译正确呢?

　　A)public void amethod(String s, int i){} (可以)

　　B)public int amethod(int i, String s){return 0;} (不可以)

　　C)private void amethod(int i, String mystring){} (不可以)

　　D)public void Amethod(int i, String s) {} (可以)

　　E)abstract void amethod(int i); (不可以)

　　选项A的amethod()方法的参数顺序和已有的不一样，所以能作为重载方法加入到Sample类中。

　　选项B和选项C的amethod()方法的参数签名和已有的一样，所以不能加入到Sample类中。对于选项C，尽管String类型的参数的名字和已有的不一样，但比较参数签名无须考虑参数的具体名字。

　　选项D的方法名为Amethod，与已有的不一样，所以能加入到Sample类中。

　　选项E的方法的参数数目和已有的不一样，因此是一种重载方法。但由于此处的.Sample类不是抽象类，所以不能包含这个抽象方法。假如把Sample类改为抽象类，就能把这个方法加入到Sample类中了。

　　再例如，以下Sample类中已经定义了一个作为程序入口的main()方法。

　　abstract public class Sample{

　　public static void main( String[] s){}

　　//加入其他方法

　　}

　　下面哪些方法可以加入到Sample类中，并且保证编译正确呢?

　　A)abstract public void main(String s, int i); (可以)

　　B)public final static int main( String[] s){} (不可以)

　　C)private void main(int i, String mystring){} (可以)

　　D)public void main( String s) throws Exception{} (可以)

　　作为程序入口的main()方法也可以被重载。以上选项A、C和D都可以被加入到Sample类中。选项B与已有的main()方法有相同的方法签名，因此不允许再加入到Sample类中。

　　方法覆盖(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(); //合法

　　}

　　图6-2 Sub类继承Base类

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

　　方法覆盖与方法重载的异同

　　方法覆盖和方法重载具有以下相同点：

　　·都要求方法同名。

　　·都可以用于抽象方法和非抽象方法之间。

　　·方法覆盖和方法重载具有以下不同点：

　　·方法覆盖要求参数签名必须一致，而方法重载要求参数签名必须不一致。

　　· 方法覆盖要求返回类型必须一致，而方法重载对此不做限制。

　　·方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类的所有方法(包括从父类中继承而来的方法)。

　　·方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。

　　·父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。

　　以下子类Sub覆盖了父类Base的method(int v)方法，并且提供了多种重载方法。

　　public class Base{