方法的继承与属性的继承有很大的不同，属性任何继承方式均可，而方法则有各种限制，于是在这里做了一个简单的总结：

1、修饰符相同的方法覆盖，即只改内部，不改外部

2、访问权限不同的方法覆盖，子类只能相对父类越来越宽松，例如父类是public，子类就不能是缺省或protect，private

3、返回值的类型覆盖，只允许相容的返回类型，例如不能将返回值为int型改为double型，但是复合类型则例外

4、final的方法覆盖,只能是父类无，子类有，而不能是父类有，子类无

5、static（静态）的方法覆盖不能有任何变动，即父类有，子类必须有，父类无，子类也必须无

实例如下：

父类：

 

  1. package ExtendMethod;
  3. public class CommonMethod {
  4.     protected int x=100;
  5.     public int getX() {//定义一个普通返回值的实例方法
  6.         return x;
  7.     }
  8.     public CommonMethod getObject() {//定义一个返回复合类型的方法
  9.         return new CommonMethod();
  10.     }
  11.     public final void setX(int ix) {
  12.         x=ix;
  13.     }
  14.     protected  void proShowMsg() {//定义一个具有保护权限的方法
  15.         System.out.println("this is protected ShowMsg() in Common class");
  16.     }
  17.     
  18.     public void pubShowMsg() {//定义一个具有公共访问权限的方法
  19.         System.out.println("this is public showMsg() in Common class");
  20.     }
  21.     static public void stShowMsg() {//定义一个静态方法
  22.         System.out.println("this is static showMsg() in Common class");
  23.     }
  24. }

 

一、修饰符相同的可以任意覆盖：

  1. public class OverrideMember_1 extends Common{
  2.     //覆盖父类中的同名实例方法
  3.     public void pubShowMsg() {
  4.         System.out.println("this is public showMsg in derive class");
  5.     }
  6.     //覆盖父类中的同名静态方法
  7.     static public void stShowMsg() {
  8.         System.out.println("this is static showMsg() in derive class");
  9.     }
  10.     //可以任意覆盖
  11.     public static void main(String args[]) {
  12.         OverrideMember_1 oa =new OverrideMember_1();
  13.         oa.pubShowMsg();
  14.         oa.proShowMsg();
  15.     }
  16. }

二、访问权限不同的覆盖，只能越来越宽松，private——>public的方向

  1. public class OverrideMember_2 extends Common{
  2.     public void proShowMsg() {//覆盖父类中的protect方法，public > protect，正确
  3.         System.out.println("this is public ShowMsg()");
  4.     }
  5.     /*protected void pubShowMsg() {//权限越来越严格,错误，protect < public
  6.         System.out.println("this is protect ShowMsg()");
  7.     }*/
  8. }

三、返回值类型的覆盖

  1. public class OverrideMember_3 extends Common {
  2.     //覆盖getX（）方法，但返回的数据类型不同,原方法是int型，错误
  3.     /*public double getX() {
  4.         return (double)x;
  5.     }*/
  6.     //覆盖getObject(),返回类型相容，正确,原方法的返回类型是新common对象，复合类型
  7.     public OverrideMember_3 getObject() {
  8.         return new OverrideMember_3();
  9.     }
  10. }

四、final的方法覆盖，只能从无到有，不能从有到无

  1. public class OverrideMember_4 extends Common{
  2.     //覆盖getX()方法，并将其指定为最终方法，正确,原方法为public int getX()
  3.     public final int  getX() {
  4.         return x;
  5.     }
  6.     //覆盖最终方法，错误，原方法为 public final void setX()
  7.     /*public void setX(int ix) {
  8.         x=ix;
  9.     }*/
  10. }

五、static不能有任何改变

  1. public class OverrideMember_5 extends Common{
  2.     //试图覆盖实例方法，将其改为静态方法，错误，原型为 public void pubShowMsg()
  3.     /*public static void pubShowMsg() {
  4.         System.out.println("this is public ShowMsg()");
  5.     }*/
  6.     //试图覆盖静态方法，并将其指定为实例方法，错误
  7.     /*public void stShowMsg() {
  8.         System.out.println("this is static ShowMsg()");
  9.     }*/
  10. }
  11. //总结，静态与实例之间不能相互转换

 

版权声明：本文为gambler原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/gambler/p/8549810.html