方法覆盖说明（摘录并整理于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(); //合法}?