JAVA 方法重载,方法重写,继承

From: http://www.dlog.cn/lvpin/diary/2349

 

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

        public void train (Dog dog){

        //训练小狗站立，排队，做算数

        }

        public void train(Monkey monkey){

        //训练猴子骑自行车等

        }

        再如某个类的一个功能是比较两个城市是否相同，一种方式是比较两个城市的名字，一种是除了比较两个城市的名字外，还要比较所在国家的名字。

        publi boolean isSameCity (String city1,String city2){

        return city1.equals(city2);

        }

        public boolean isSameCity(String city1,String city2,Stirng 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)

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

        // 参数为 int 类型，因此执行max（int a, int b）方法

·          Math.max(1,2);

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

·          Math.max(1.0F,2.9F);

 

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

        重载方法满足以下条件

        方法名相同

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

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

        方法的修饰符可以不相同

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

        例如 ：public class Sample {

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

        下面哪个方法可以加入到 Sample 类中去？

·          public void amethod(String s,int i)                //OK

·          public int amethod(int i,String s){return 0}   //NO 

¨        //不行，参数签名和类中方法一样

·          public void amethod(int i,String myString){} //NO

¨        //不行，参数签名和类中方法一样

·          public void Amethod (int i,Sting s){} //              OK

¨        //可以，因为 Amethod 和amethod 是两个不同的方法名称。

·          abstract void amethod( int i);          //NO

¨        尽管它的参数列和类中方法参数不一样，但是，此处的Sample 类不是抽象类，所以不能包括这个抽象方法。假如把Sample 类改为抽象类，就能把这个方法加入到 Sample 类中了。

·          （源码）

·            public boolean compareCity(String city1,String city2){

·                        return city1.equals(city2);

·                    }

·                   

·                public int compareCity(String city1,String city2){

·                       

·                        if(city1.equals(city2)){

·                                return 1;

·                            }else{

·                                return 0;

·                            }

·                    }

·          编译错误：compareCity(java.lang.String,java.lang.String) is already defined

·          // compareCity(String ,String ) 方法已经被定义过

        作为程序的入口 main（）方法也可以被重载。

        public static void main(String args[]){

                 

                  }

             

              public void main(String s,int i){}               //可以

             

              private void main(int i,String myString []){}       //可以

         

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

         

              public final static int main(String args[]){}  //不可以

                它已经和已有的 main （）方法有相同的签名，因此不允许再加到这个类中来。

             main(java.lang.String []) is already defined in Sample

 

 

方法覆盖

        假如有100个类，分别是 Sub1,Sub2,Sub3…….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};// 编译错误

¨        }

¨        method() in Simon.Sub cannot overrid method() in Simon.Base;

¨        attempting to use incompatible return type

¨        在Simon 包 Sub 中的方法不不能重写（覆盖） 在 Simon 包 Base类中的方法

¨        试图用不匹配的返回类型

        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 mehod(int a){………return 0.}  //重载method 方法

¨        }

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

¨        public class Base{

¨             public void method(){…………..}

¨        }

 

¨        public class Sub extends Base{

private void method(){……….}//覆盖 Base 类的method 方法,但是缩小了 父类方法访问权限

}

¨        method() in Simon.Sub cannot override method() in Simon.Base;

¨        attempting to assign weaker access privileges ;

¨        was public

¨        Simon 包中 的 Sub 类 method()不能重写、覆盖 Simon 包中Base类的 method()方法。

¨        试图分配一个更弱的访问权限

¨        原来是 public (现在却是 private)

·          为什么子类方法不允许缩小父类方法的访问权限呢？这时因为假如没有这个限制，将于Java 语言的多态机制发生冲突。

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

¨        base.method();

¨        Java 编译器认为以上是合法的代码，但是在运行时，根据动态绑定规则，Java 虚拟机会调用base 变量所引用的Sub 实例的 method（）方法，如果这个方法为 private 类型，Java 虚拟机就没有办法访问它.所以为了避免这样的矛盾，Java 语言不允许子类方法缩小父类中被覆盖方法的权限。

        3）子类方法不能抛出比父类方法更多的异常。

·          子类方法抛出的异常必须和父类方法抛出的异常相同，或者子类方法抛出的异常类是父类抛出的异常类的子类。

¨        假设异常类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 methos () 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(){} //编译错误

·          }

·          method () in Simon.Sub cannot override method() in Simon.Base;

·          Overridden method is static

·          在包Simon ，Sub类中的 method() 方法不能够重写 Base 类中的 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} }

·          子类隐藏父类的静态方法和子类覆盖父类的实例方法，这两者的区别就在于：运行时，JVM把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。

¨       Base.java

¨        package Simon;

¨         

¨        public class Base{

¨          

¨           void method(){

¨               System.out.println("method of Base !");//实例方法

¨               }

¨           static void staticMethod(){

¨               System.out.println("static method of Base !");//静态方法

¨               }

¨           }

¨          Sub.java

¨        package Simon;

¨         

¨           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

¨                  

¨                   }

¨           }

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

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

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

        7）父类的非静态方法不能被子类覆盖为静态方法。

·          以下代码编译有错误

·          public class Base {

¨        public void method(){}

·          }

·          public class Sub extends Base{

·             public static void method(){} //编译错误

·          }

¨        method () in Simon.Sub cannot override method() in Simon.Base;

¨        overriding method is static .

 

        8）父类的私有方法不能被子类覆盖

·          子类方法覆盖父类方法的前提是：子类必须能继承父类的特定方法。

·          由于父类中的某个私有方法无法被子类访问，继承，所以也不存在被子类覆盖的关系。

¨        示例：

¨       Base.java

¨        package Simon;

¨         

¨        public class Base{

¨          

¨               private String showMe(){

¨                       return "Base";

¨                   }

¨              

¨               public void print(){

¨                       System.out.println(showMe());//到底调用哪一个showMe(),是Base 类还是Sub类中的。

¨                   }

¨           }

¨          Sub.java

¨        package Simon;

¨         

¨           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 String showMe(){

¨                         return "Base";

¨                     }

¨        在执行以上Sub 类的main （）方法，会打印出 Sub，这是因为此时Sub 类的 showMe() 方法覆盖了 Base 类的showMe() 方法。因此尽管print()方法在Base 类中定义，JVM 还是会调用当前Sub 实例的 ShowMe 方法。

        9）父类的抽象方法可以被子类通过两种途径覆盖掉，一是子类实现父类的抽象方法，二是子类重新声明父类的抽象方法。

¨        public abstract class Base{

¨            abstract void method1();

¨            abstract void method2

¨        }

¨        public abstract class Sub extends Base{

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

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

¨        }

Ø       狭义的理解，覆盖仅指子类覆盖父类的具体方法，即非抽象方法，在父类中提供了方法的默认实现方式，而子类采用不同的实现方式。

Ø       例如，以下代码编译会有误。

Ø       public abstract class Base{

Ø         

Ø              abstract void method1();

Ø              abstract void method2();

Ø          }

Ø          public abstract class Sub extends Base{

Ø             

Ø             private void method(){//编译有误，不能缩小访问权限

Ø             

Ø              System.out.println("method test!");

Ø             }

Ø             

Ø             private abstract void method2();//编译有误，不能缩小访问权限，且会出现以下错误

Ø             

Ø          }

Ø       illegal combination of modifiers : abstract and private

Ø       abstract 不能和 private 关键字一起使用。抽象方法必须需要被实现，但是 private 是私有的，外界无法访问，所以不行。

        10）父类的非抽象方法可以被覆盖为抽象方法

·          public class Base{

·              void methos();

·          }

·          public abstract class Sub extends Base{

·             public abstract void method(); //合法

·          }

 

 

 

Java 方法重载 （OverLoad）与方法覆盖（Override）的区别

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

        都要求方法名相同

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

        不同点

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

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

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

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

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