方法覆盖说明（摘录并整理于java面向对象编程—孙卫琴）

覆盖方法约束：

 

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 a;
    }
}

 

 

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语言不允许子类方法缩小父类中被覆盖方法的访问权限。

 

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 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虚拟机会调用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虚拟机把静态方法和所属类绑定，而把实例方法与所属实例绑定。下面举例来解释这一区别，在例子中，Base类和他的子类Sub类中都定义了实例方法method()和静态方法staticMethod()。

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(); //Base类型变量sub1引用Sub类实例
     sub1.method();    //打印 method of Sub
        sub1.staticMethod();    //打印static method of Base
        
        Sub sub2 = new Sub(); //Sub类型变量sub2引用其本身的实例
     sub2.method();    //打印 method of Sub
        sub2.staticMethod();    //打印static method of Sub
    }
}

 

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

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

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

 

 

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

 

    例如以下代码是不合法的：

public class Base{
    void method(){}
}

public class Sub{
    static void method(){}    //编译出错，不能把父类实例方法覆盖为静态方法
}

 

 

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

 

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

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访问权限，其他代码不变。再执行以上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()方法，仅仅扩大访问权限，但不实现
}

 

    说明：侠义的理解，覆盖仅指子类覆盖父类的具体方法，即非抽象方法，在父类中提供了方法的默认实现方式，而子类采用不同的实现方式。我们为了叙述方便，也把子类实现父类的抽象方法也看作方法覆盖。

 

    例如以下代码不合法：

 

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 class Sub extends Base{
    public abstract void method();    //合法
}