Java-重载重写（冷静分析）

Posted 2020-10-09 薛定谔的猫。

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java-重载重写（冷静分析）相关的知识，希望对你有一定的参考价值。

一、方法的重载

　　重载就是根据不同的数据类型，自动匹配对应的方法。重载在编译的时候就决定调用哪个方法了，和重写不一样。（常见，构造函数重载）。

举个栗子：

1、基本数据类型的重载：

 1 /**
 2  * @author 薛定谔的猫
 3  * 基本数据类型的重载
 4  * */
 5 public class Main {
 6     
 7     static void methed( byte b) {
 8         System.out.println("byte:method");
 9     }
10     
11     static void method(double d) {
12         System.out.println("double:method");
13     }
14     
15     static void method(int i) {
16         System.out.println("int:method");
17     }
18     
19     static void method(String s) {
20         System.out.println("String:method");
21     }
22     
23     public static void main(String[] args) {
24         methed((byte)1);
25         method(2.0);
26         method(1);
27         method("zpoor");
28     }
29 }
30 
31 /*
32  * 结果：
33  *         byte:method
34  *        double:method
35  *        int:method
36  *        String:method
37 */

2、带对象引用参数的重载

 1 /**
 2  * @author 薛定谔的猫
 3  * 带有对象引用参数的重载*/
 4 class Animal {
 5     
 6 }
 7 
 8 class Pig extends Test{
 9     
10 }
11 
12 class Test {
13     static void method(Test a) {
14         System.out.println("Animal");
15     }
16     
17     static void method(Pig p) {
18         System.out.println("Pig");
19     }
20     
21     public static void main(String[] args) {
22         Test a = new Test();
23         Pig p = new Pig();
24         Test b = new Pig();
25         
26         method(a);
27         method(p);
28         method(b);//为啥不是Pig，而是Animal
29         /*
30          * 盲目分析：看的是引用类型而不是对象类型，重载在编译时候就决定了，
31          *             引用类型决定了哪个重载方法。
32          * */
33         
34     }
35 }
36 
37 /**
38  * 结果：
39  *     Animal
40     Pig
41     Animal
42 */

总结：重载的规则

1、重载的方法必须改变参数列表，参数必须不同（参数的个数，参数的类型，参数的顺序）

2、被重载的方法与返回值没有关系，不是通过返回值类型来判断方法是不是重载了。

3、重载的方法可以改变访问修饰符。

4、重载的方法可以声明新的或者更广的建厂异常。

5、方法能够在一个类或者一个子类中被重载。

二、方法的重写

重写只能出现在继承关系中，只要父类的方法不是final修饰的，都可以重写父类的方法。重写的有点：能够定义某个子类特有的特征。

举个栗子：

 1 /**
 2  * @author 薛定谔的猫
 3  * 重载例子*/
 4 class Animal {
 5     public void eat() {
 6         System.out.println("吃点东西");
 7     } 
 8 }
 9 
10 class Horse extends Animal {
11     public void eat() {
12         System.out.println("吃点草");//实现重载
13         }
14 }

对于父类继承的抽象方法，要么子类是重写该方法，要么把子类也设为抽象子类。所以抽象方法可以说是必须重写的方法。

重写的意义：

　　重写可以实现多态，用父类的引用来指向子类对象。

举个栗子：

 1 /**
 2  * @author 薛定谔的猫
 3  * 重写例子*/
 4 public class Test {
 5     public static void main(String[] args) {
 6         Animal p = new Pig();
 7         p.eat();
 8     }
 9 }
10 
11 
12 class Animal {
13     public void eat() {
14         System.out.println("吃点东西吧");
15     }
16 }
17 
18 class Pig extends Animal {
19     public void eat() {
20         System.out.println("吃点猪食beautiful");
21     }
22 }