多态的概念：通俗来说，就是多种形态。具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状 态。

假如我们去喂食宠物，对于猫咪我们肯定喂食猫粮，那么万一是狗肯定对应的是狗粮。

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

一、多态的实现条件

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

1.必须在继承体系下

2 .子类必须要对父类中方法进行重写

3. 通过父类的引用调用重写的方法

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

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

在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道,也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态

二、重写

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

【方法重写的规则】

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

【重写的设计原则】

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

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

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代 表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体 调用那个类的方法

三、向上转型和向下转型

1.向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。 语法格式：父类类型 对象名 = new 子类类型()

 Animal animal = new Cat("元宝",2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

【使用场景】

直接赋值方法传参方法返回

 public class TestAnimal {
     // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
     public static void eatFood(Animal a){
         a.eat();
     } 
     // 3. 作返回值：返回任意子类对象
         public static Animal buyAnimal(String var){
         if("狗".equals(var) ){
             return new Dog("狗狗",1);
         }else if("猫" .equals(var)){
             return new Cat("猫猫", 1);
         }else{
             return null;
         }
     }
     public static void main(String[] args) {
         Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
         Dog dog = new Dog("小七", 1);
         eatFood(cat);
         eatFood(dog);
         Animal animal = buyAnimal("狗");
         animal.eat();
         animal = buyAnimal("猫");
         animal.eat();
     }
 }

2.向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

 public class TestAnimal {
     public static void main(String[] args) {
         Cat cat = new Cat("元宝",2);
         Dog dog = new Dog("小七", 1);
         // 向上转型
         Animal animal = cat;
         animal.eat();
         animal = dog;
         animal.eat();
         // 编译失败，编译时编译器将animal当成Animal对象处理
         // 而Animal类中没有bark方法，因此编译失败
         // animal.bark();
         // 向上转型
         // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
         // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
         cat = (Cat)animal;
         cat.mew();
         // animal本来指向的就是狗，因此将animal还原为狗也是安全的
         dog = (Dog)animal;
         dog.bark();
     }
 }

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

 public class TestAnimal {
     public static void main(String[] args) {
         Cat cat = new Cat("元宝",2);
         Dog dog = new Dog("小七", 1);
         // 向上转型
         Animal animal = cat;
         animal.eat();
         animal = dog;
         animal.eat();
         if(animal instanceof Cat){
             cat = (Cat)animal;
             cat.mew();
         } if(
             animal instanceof Dog){
             dog = (Dog)animal;
             dog.bark();
         }
     }
 }