方法覆盖（Override）的约束(一)

  1.      子类方法的名称、参数签名和返回类型必须和父类方法的名称、参数签名和返回类型一致。

 

public class Base {
    public void method() {… …}
}
public class Sub extends Base {
    public void method() {… …}
    public int method(int a) {
         return 0;
    }
}

 

 上述代码中子类覆盖了父类的一个方法，然后又定义了一个重载方法，这是合法的。

 2.  子类方法不能缩小父类方法的访问权限。

 

public class Base {
    public void method() {… …}
}
public class Sub extends Base {
    private void method() {… …}  //编译错误，子类方法缩小了父类方法的访问权限
}

  

  3.  子类方法不能抛出比父类方法更多的异常。子类方法抛出的异常必须和父类抛出的异常相同，或者子类方法抛出的异常是父类方法抛出的异常的子类。

 4.  方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间。在同一个类中的方法只能被重载，不能被覆盖。

public class Base {
    public void method() throws ExceptionSub1{… …}
}	
public class Sub1 extends Base {
    public void method() throws ExceptionBase {… …}     //编译错误
}
public class Sub2 extends Base  {
    public void method throws ExcetptionSub1,ExceptionSub2() {… …}   //编译错误
}

 

 

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

public class Base {
    public static void method() {… …}
}
public class Sub extends Base {
    public void method() {… …}
}

 6.  子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法。在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束：方法的参数签名一致，返回类型一致，不能缩小父类方法的访问权限，不能抛出更多的异常。

     子类隐藏父类的静态方法和子类覆盖父类的实例方法的区别：运行时，Java虚拟机把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。

     分析下面例子：

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  这是因为：父类Base的静态方法staticMethod（）不能被子类覆盖
	Sub sub2 = new Sub();	//sub2变量被声明为Sub类型，引用Sub实例
	sub2.method();		//打印method of Sub
	sub2.staticmethod();		//打印static method of Sub	这是因为：父类Base的静态方法staticMethod()被子类的staticMethod()方法隐藏
   }
}

  7.   父类的私有方法不能被子类覆盖。

 

class Base {
    private String showMe() {
	return "Base";
    }
    public void print() {
	System.out.println(showMe());
    }
}
public class Sub extends Base{
    public String showMe() {
	return "Sub";
    }
    public static void main(String[] args) {
	Sub sub = new Sub();
	sub.print();
    }
}

 打印结果：Base 

 Base类的private类型的showMe()方法不能被Sub类继承，因此Base类的showMe()方法和Sub类的showMe()方法之间并没有覆盖关系。

 

 

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

 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（）方法，仅仅扩大访问权限，但不实现
｝

 

10. 父类的非抽象方法可以被子类覆盖为抽象方法。