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

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

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多态的动态绑定。

写博客是为了记住自己容易忘记的东西，另外也是对自己工作的总结，希望尽自己的努力，做到更好，大家一起努力进步！

如果有什么问题，欢迎大家一起探讨，代码如有问题，欢迎各位大神指正！

给自己的梦想添加一双翅膀，让它可以在天空中自由自在的飞翔！