Java 重写（重点，一定要掌握！）

重写的要求：

• 子类方法的形参列表和方法名必须和父类方法的形参列表和方法名一样
  
• 子类方法的返回类型必须是父类方法返回类型或为其子类型。例如父类方法返回类型为Object类，那么子类的返回类型可以是Object，也可以是String
  
• 子类方法的访问权限必须大于等于父类方法； (访问权限：public>default>protected>private)
  
• 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。
  

重写和重载区别

重载(Overload)重写(Override)发生范围本类父子类形参列表形参类型/个数/顺序至少一个不同父子类必须相同返回类型没有要求子类方法的返回类型必须是父类方法返回类型或为其子类型修饰符无要求子类方法的访问权限必须大于等于父类方法扩展

在调用一个方法时，先从本类中查找是否有对应的方法(this.func(this))
如果没有再到父类中查找是否有对应的方法(super.func(this))
如果仍然没有就要将参数类型转成其父类类型之后再到本类中看是否有对应的方法(this.func(super))
如果仍然没有就再到父类中查找是否有对应的方法(super.func(super))
优先级：从高到低

1. this.func(this)
2. super.func(this)
3. this.func(super)
4. super.func(super)

复制代码

this和super有点模糊的可以去看一下这篇 this和super关键字
案例

1. class One{
2.     public void test(One obj) {
3.         System.out.println("调用了One的方法，参数类型是One");
4.     }
5.     public void test(Three obj){
6.         System.out.println("调用了One的方法，参数类型是Three");
7.     }
9.     public void test(){
10.         System.out.println("1111111");
11.     }
13.     public void show(){
14.         System.out.println("One show");
15.     }
16. }
18. class Two extends One{
19.     @Override
20.     public void test(One obj){System.out.println("调用了Two的方法，参数类型是One");}
21. //    @Override
22. //    public void test(Three obj){
23. //        System.out.println("调用了Two的方法，参数类型是Three");
24. //    }
25.     @Override
26.     public void show(){
27.         System.out.println("Two show");
28.     }
29. }
31. class Three extends Two {}
33. class Four extends Three {}

复制代码

1. public static void main(String[] args) {
2.         One one = new One();
3.         Two two = new Two();
4.         Three three = new Three();
5.         Four four = new Four();
7.         one.test(one);
8.         // one是One类创造的对象，参数类型是One类，先从One类中找是否有test(One obj)方法，有所以直接调用
9.         // 结果：调用了One的方法，参数类型是One
11.         one.test(two);
12.         // one是One类创造的对象，参数类型是Two类，先从One类中找是否有test(Two obj)方法，
13.         // 没有，所以到One类的父类Object中查看，Object也没有test(Two obj)方法
14.         // 所以对参数进行转型，将Two类转成其父类One，再到One类中找是否有test(One obj)方法，有所以直接调用
15.         // 结果：调用了One的方法，参数类型是One
17.         two.test(three);
18.         // two是Two类创造的对象，参数类型是Three类，先从Two类找是否有test(Three obj)方法
19.         // 没有，所以到Two类的父类One中查看
20.         // 找到One类中有test(Three obj)方法，直接调用
21.         // 结果：调用了One的方法，参数类型是Three
23.         two.test(four);
24.         // two是Two类创造的对象，参数类型是Four类，先从Two类找是否有test(Four obj)方法
25.         // 没有，所以到Two类的父类One中查看
26.         // One类中没有test(Four obj)方法，所以到One类的父类Object中查看，Object也没有test(Four obj)方法
27.         // 所以对参数进行转型，将Four类转成其父类Three
28.         // 再到Two类中找是否有test(Three obj)方法，没有
29.         // 再到Two类的父类One中看是否有test(Three obj)方法，有所以直接调用
30.         // 结果：调用了One的方法，参数类型是Three
32.         One one1 = new Two(); // 引用的是Two对象：父类One的引用指向子类的类型
33.         //Two two1 = new One(); // 反过来不行，子类的引用不能指向父类
34.         one1.test(one1);
35.         // one1是Two类创造的对象，参数类型是Two类，先从Two类找是否有test(Two obj)方法
36.         // 没有，所以找Two类的父类One，看是否有test(Two obj)方法
37.         // 还是没有，所以到One类的父类Object中查看，Object也没有test(Two obj)方法
38.         // 所以将参数类型Two类转为其父类One，再到本类(Two)查找是否有test(One obj)方法，有所以直接调用
39.         // 结果：调用了Two的方法，参数类型是One
40.     }

复制代码