理解Java中的多态机制，一篇就够啦

ゝ一纸荒年。 2021-09-24 07:10 237阅读 0赞

> `创作不易，如果觉得这篇文章对你有帮助，欢迎各位老铁点个赞呗，您的支持是我创作的最大动力！`

### 文章目录 ###

*  Java中的多态
 *   *  1 多态是什么
     *  2 多态的语法格式
     *  3 满足多态的条件
     *  4 使用多态好处
     *  5 多态中的类型转换
     *  6 多态的实现方式
     *  7 多态简单使用案例
     *  8 多态分析

# Java中的多态 #

## 1 多态是什么 ##

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。用白话来说，就是多个对象调用同一个方法，得到不同的结果。

## 2 多态的语法格式 ##

`父类类名 引用名称 = new 子类类名();`

当是多态时，该**引用名称**只能访问父类中的属性和方法，但是访问的时候，会优先访问子类重写以后的方法。

## 3 满足多态的条件 ##

*  子类必须继承父类
 *  子类必须重写父类的方法
 *  父类引用指向子类对象，即：父类类名 引用名称 = new 子类类名();

## 4 使用多态好处 ##

*  使用多态可以使代码之间的`耦合度`降低
 *  减少冗余代码的同时，也使得项目的扩展能力更强
    
    注：**耦合度**指的是代码（程序）之间的关联程度

## 5 多态中的类型转换 ##

Java多态中，有两种类型转换：`向上转型`和`向下转型`

*  **向上转型**  
    向上转型，也叫做自动类型转换，`子类型赋值给父类型（父类型的引用指向子类型），构成多态`  
    父类类型 引用名称 = new 子类类名();
    
    当使用多态方式调用方法时，该引用名称只能访问父类中的属性和方法。编译器首先检查父类中是否有该方法，如果没有，则编译错误。如果有，再去调用子类的同名（重写）方法。
 *  **向下转型**  
    向下转型，也叫做强制类型转换，父类型赋值给子类型
    
    当使用多态时，并且访问子类独有的属性或方法时，则必须进行向下转型
    
    当进行向下转型时，建议先使用 `instance of` 关键字进行判断，判断合法时，则在转为对应的类型，否则可能会出现类型转换异常 java.lang.ClassCastException。
    
    说明：`instance of` 关键字用于判断一个对象，是否属于某个指定的类或其子类的实例。

## 6 多态的实现方式 ##

*  普通子类重写父类方法
 *  接口  
    生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
    
    USB接口也很典型，有了这个，使得接口统一，生活更加方便
 *  抽象类和抽象方法

## 7 多态简单使用案例 ##

场景：假如有个饲养员，需要给不同的宠物喂食，下面给出**使用多态**和**不使用多态**的实现方式。

*  **不使用多态的实现：**
    
    首先定义一个抽象类`Animal`、一个饲养员类`AnimalKeeper`、一个宠物类`Dog`和一个宠物类`Cat`。
    
        public abstract class Animal { 
        
            public void eat() { 
                System.out.println("动物吃东西！");
            }
        }
    
        /** * 饲养员 */
        public class AnimalKeeper { 
        
            /** * 给宠物猫喂食 * * @param cat */
            public void feed(Cat cat) { 
                cat.eat();
            }
        
            /** * 给宠物狗喂食 * * @param dog */
            public void feed(Dog dog) { 
                dog.eat();
            }
        
        }
    
        public class Dog extends Animal { 
        
            @Override
            public void eat() { 
                System.out.println("狗啃骨头！");
            }
        }
    
        public class Cat extends Animal { 
        
            @Override
            public void eat() { 
                System.out.println("猫吃鱼！");
            }
        }
    
    **测试类：**
    
        public class PolymorphicTest { 
        
            public static void main(String[] args) { 
                //创建饲养员对象
                AnimalKeeper animalKeeper = new AnimalKeeper();
        
                //创建宠物对象
                Cat cat = new Cat();
                animalKeeper.feed(cat);//猫吃鱼！
        
                Dog dog = new Dog();
                animalKeeper.feed(dog);//狗啃骨头！
            }
        }
    
    以上实现看起来没有什么问题，也容易理解，在目前情况下，饲养员可以满足喂养宠物的需求。但是，过了一周，饲养员又喂养了一只鸟，这时候不得不修改AnimalKeeper类，使其可以饲养宠物鸟，不仅违反了Java中的开闭原则，而且以上代码的实现，扩展性极差。
 *  **使用多态的实现：**  
    只需要对以上代码中，饲养员类`AnimalKeeper`进行替换，新增一个饲养员类`AnimalKeeperPolymorphic`类。
    
        /** * 饲养员 */
        public class AnimalKeeperPolymorphic { 
        
            /** * 饲养员给宠物喂食 * * @param animal */
            public void feed(Animal animal) { 
                animal.eat();
            }
        
        }
    
    **测试用例：**
    
        public static void change() { 
           //创建饲养员对象
            AnimalKeeperPolymorphic animalKeeper = new AnimalKeeperPolymorphic();
        
            //创建宠物对象
            Cat cat = new Cat();
            animalKeeper.feed(cat);//猫吃鱼！
        
            Dog dog = new Dog();
            animalKeeper.feed(dog);//狗啃骨头！
        }
    
    这种实现有什么好处呢，当新需求来了，需要扩展时，不需要修改饲养员的代码。比如说刚才那个需求，新增加一个宠物鸟，只需要新建一个宠物鸟类，实现Animal接口，不仅遵循了`OCP`原则，也可以实现饲养宠物鸟的功能。

## 8 多态分析 ##

以上文中示例代码进行分析，看看多态是如何使用的。

AnimalKeeperPolymorphic中的feed()方法，使用了多态。

当饲养员喂养宠物狗时，其实执行的是：

Animal animal = new Dog();

当饲养员喂养宠物猫时，其实执行的是：

Animal animal = new Cat();

这种属于向上转型，里面有继承（cat继承Animal）关系，重写了父类eat()方法，子类型赋值给父类型（父类型的引用指向子类型），构成了多态。

**Animal `animal` = new Cat();** 程序在编译阶段，`animal引用类型`被编译器看做Animal类型，所以**程序在编译阶段**，`animal引用`绑定的是Aninmal类中的eat()方法，这个过程叫做`Java多态的静态绑定`。

程序在运行的时候，堆中的对象实际上是Cat类型，而Cat对象已经覆盖（重写）了父类Animal的eat()方法，所以**程序在运行阶段**，对象绑定的方法是Cat中的eat()方法，这个过程叫做`Java多态的动态绑定`。

> 写博客是为了记住自己容易忘记的东西，另外也是对自己工作的总结，希望尽自己的努力，做到更好，大家一起努力进步！  
>   
> 如果有什么问题，欢迎大家一起探讨，代码如有问题，欢迎各位大神指正！  
>   
> 给自己的梦想添加一双翅膀，让它可以在天空中自由自在的飞翔！