Java多态详解（1）

客官°小女子只卖身不卖艺 2023-10-14 20:02 33阅读 0赞

## 多态 ##

### 多态的概念 ###

> 所谓多态，通俗地讲，就是多种形态，**具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态**。

比如：

![fc9c3c575ee944889f841add1b99c1ad.png][]

这一时间爆火的“现代纪录片”中，麦克阿瑟总是对各种“名人”有不同的评价，这也可看做多态。

总的来说：**同一件事情，发生在不同对象身上，就会产生不同结果**。

### 多态的实现条件 ###

在Java中要实现多态，必须满足以下几个条件，缺一不可：

> **1.必须在继承体系下（向上转型）**
> 
> **2.子类必须对父类中的方法进行重写**
> 
> **3.通过父类的引用调用重写的方法**

**多态体现：在代码运行时，当传递不同对象，会调用对应类中的方法。**

**举个例子：**

class Animal {
        String name;
        int age;
    
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void eat() {
            System.out.println(name + "吃饭");
        }
    }
    
    class Dog extends Animal {
        public Dog(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println(name + "吃骨头");
        }
    }
    
    class Cat extends Animal {
        public Cat(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println(name + "吃鱼干");
        }
    }
    
    public class TestAnimal {
        //编译器在编译代码的同时，并不知道要调用Cat还是Dog中的eat方法
        //等程序运行起来后，形参a引用的具体对象确定后，才知道调用哪个方法
        //注意：此处的形参类型必须是父类类型才可以
        public static void eat(Animal a) {
            a.eat();
        }
    
        public static void main(String[] args) {
            Dog dog = new Dog("小七", 2);
            Cat cat = new Cat("元宝", 1);
            eat(dog);
            eat(cat);
        }
    }

![c954e178be29425882851a3c013c7983.png][]

> 当类的调用者在编写eat这个方法时，参数类型为Animal（父类），此时在该方法内部**不知道 ，也不关注**当前的a引用指向的是哪个类型（哪个子类）的实例。此时a这个引用调用的eat方法可能会有多种不同的表现（**和a引用的实例相关**），这个行为就叫多态。

![abe8d8c7896d4bdcbe41b5ff1ce9adbc.png][]

### 重写 ###

> 重写(override)：也称为覆盖。**重写是子类对父类非静态，非private修饰，非final修饰，非构造方法等的实现过程进行重新编写，****返回值和形参都不能改变，即外壳不变，核心重写**！ 重写的好处在于**子类可以根据需要，定义特定于自己的方法。也就是说子类能够根据需要实现父类的方法。**

**方法重写的规则**

> **1.子类在重写父类的方法时，一般必须与父类方法原型一致：即返回值类型 方法名（参数列表）要完全一致**
> 
> **2.被重写的方法返回值类型可以不同，但是必须具有父子关系的**
> 
> **3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为protected**
> 
> **4.父类被static,private,final修饰的方法都不能被重写**
> 
> **5.重写的方法，可以用@Override注解来显式指定。有了这个注解能帮我们进行一些合法性的校验。例如不小心将方法名字拼写错了（比如上面的eat错写为aet）,这时编译器就会发现父类中没有aet方法，就会显示编译报错**

**重写和重载的区别**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>区别点</td> 
   <td>重写（override）</td> 
   <td>重载（overlaod）</td> 
  </tr> 
  <tr> 
   <td>参数列表</td> 
   <td>一定不能修改</td> 
   <td>必须修改</td> 
  </tr> 
  <tr> 
   <td>返回类型</td> 
   <td>一定不能修改（除非可以构成父子类关系）</td> 
   <td>可以修改</td> 
  </tr> 
  <tr> 
   <td>访问限定符</td> 
   <td>不能做更严格的限制（可以降低限制）</td> 
   <td>可以修改</td> 
  </tr> 
 </tbody> 
</table>

即：**方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现**

**重写的设计原则**

> 对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用共性的内容，并且添加或者改动新的内容。

例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示的时候，不仅仅可以显示电话号码，还可以显示地区，姓名等。在这个过程当中，我们**不应该在原来老的类上进行修改，因为原来的类，可能还有用户使用，正确的做法是：新建一个手机类，对来电显示进行方法重写即可，这就达到了今天的需求**。

![502182356f8e464e8a18e1591f2cf9b1.png][]

> 静态绑定：也称为前期绑定（早绑定），即在编译时，根据用户所传递实参类型就确定了具体调用哪个方法。典型代表函数重载。
> 
> 动态绑定：也成为后期绑定（晚绑定），即在编译时，不能确定方法的行为，需要等到程序运行时，才能确定具体调用哪个方法。

[fc9c3c575ee944889f841add1b99c1ad.png]: https://img-blog.csdnimg.cn/fc9c3c575ee944889f841add1b99c1ad.png
[c954e178be29425882851a3c013c7983.png]: https://img-blog.csdnimg.cn/c954e178be29425882851a3c013c7983.png
[abe8d8c7896d4bdcbe41b5ff1ce9adbc.png]: https://img-blog.csdnimg.cn/abe8d8c7896d4bdcbe41b5ff1ce9adbc.png
[502182356f8e464e8a18e1591f2cf9b1.png]: https://img-blog.csdnimg.cn/502182356f8e464e8a18e1591f2cf9b1.png