覆盖又叫重写，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。
对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。
在覆盖要注意以下的几点：   
1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.   
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。   
3、重写的方法的返回值必须和被重写的方法的返回一致；   
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；   
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。   
6、静态方法不能被重写为非静态的方法（会编译出错）。

1. class Father {
   
2.         public void method(){
   
3.                 System.out.println("This is Father's method");
   
4.         }
   
5. }
   
6. 
   
7. class Son1 extends Father{
   
8.         public void method(){
   
9.                 System.out.println("This is Son1's method");
   
10.         }
    
11. }
    
12. 
    
13. class Son2 extends Father{
    
14.         public void method(){
    
15.                 System.out.println("This is Son2's method");
    
16.         }
    
17. }
    
18. 
    
19. public class Test {
    
20.         public static void main(String[] args){
    
21.                 Father s1 = new Son1();
    
22.                 s1.method();
    
23.                
    
24.                 Father s2 = new Son2();
    
25.                 s2.method();
    
26.         }
    
27. }
    

复制代码

结果是：
This is Son1's method
This is Son2's method
通过运行结果可以看到，尽管我们引用的类型是Father类型的，但是运行时却是调用的它实际类型（也就是Son1和Son2）的方法，这就是动态绑定。在java语言中，继承中的覆盖就是是动态绑定的，当我们用父类引用实例化子类时，会根据引用的实际类型调用相应的方法。

  

值得学习ing!