//苹果义父类
class Animal{

    public String name;
    public void eat(){
        System.out.println("正在吃饭");
    }
}

//定义子类
class Cat extends Animal{
    public Cat(String name){
        this.name = name;
    }
    @Override
    public void eat() {
        System.out.println(name+"吃鱼");
    }
}
class Dog extends Animal{

    public Dog(String name){
        this.name = name;
    }
    @Override
    public void eat() {
        System.out.println(name+"吃狗粮");
   }
}

//定义测试类
public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Animal animal = new Cat("猫");
        // 调用的是 Cat 的 eat的方法
        animal.eat();
        Animal animal1 = new Dog("狗");
        // 调用的是 都给 的 eat的方法
        animal1.eat();
    }

}

注意

多态的实现条件

必须满足以下几个条件, 缺一不可:

必须要在继承下
子类必须对父类中的方法进行重写
要通过父类的引用调用重写的方法

3. 重写

什么是重写?

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

@Override是覆盖的意思,也就是重写的意思

方法重写的条件

方法名相同
方法的参数列表相同(指个数, 类型, 顺序相同)
方法的返回值相同
不能重写static修饰的方法
不能重写private修饰方法
子类的访问修饰符要大于等于父类的访问修饰符, 什么意思呢? 如下图:

修饰符前后大小: public > protected > default

静态绑定: 编译的时候就确定了最终要调用的方法。重载其实就是静态绑定。比如

动态绑定: 运行时绑定，即在编译时，还是调用的是父类的方法，等到程序运行的时候,程序发生了动态绑定。比如向上转型就是发生了动态绑定

什么是向上转型下面有讲

4. 引用类型转换

多态的转型分为向上转型与向下转型两种：

4.1 向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的

当父类类型引用子类对象时, 这个过程便是向上转型.

使用格式:

父类类型变量名 = new 子类类型();

如：Animal a = new Dog();

使用场景:

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

代码如下:

class Animal{
    public String name;

    void eat(){
        System.out.println("正在吃饭");
    }
}
class Cat extends Animal{
    public Cat(String name) {
        this.name = name;
    }

    @Override
     void eat() { //默认修饰符为default
        System.out.println(name+"吃鱼");
    }
}
class Dog extends Animal {
    public Dog(String name) {
        this.name = name;
    }

    @Override
    public void eat() {
        System.out.println(name + "吃狗粮");
    }
}
    public class Test {

    //第二种:方法传参,形参为父类类型引用，可以接收任意子类的对象
    public static void eatFood(Animal animal) {
        animal.eat();
    }
    //第三种: 作返回值, 返回任意子类对象
    public static Animal buyAnimal(String var){
        if ("狗" == var){
             return new Dog("狗狗");
        }else if ("猫" == var){
            return new Cat("猫猫");
        }else {
            return null;
  }
    }
        public static void main(String[] args) {
            /*向上转型*/
            //第一种:直接赋值
            Animal animal1 = new Dog("狗");
            animal1.eat();//动态绑定

            eatFood(new Dog("狗"));//把子类作为参数传过去
            animal1 = buyAnimal("狗");
            animal1.eat();
        }

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

4.2 向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型变量名 = (子类类型) 父类变量名;

如:Cat c =(Cat) a;

前面有说在使用多态方式调用方法时，首先检查的是是否有该方法，如果没有，则编译错误；也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下：

调用就是子类的方法

不过向下转型不安全, 转型的过程中，一不小心就会遇到这样的问题，请看如下：

可以看出来段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Dog类型对象，运行时，当然不能转换成Cat对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

 public class Test {

public static void main(String[] args) {

        Animal a = new Cat();  
       
        // 向下转型  

        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse

        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse

        }
    }  
}

5. 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码如下：

//定义父类
public abstract class Animal {
   public abstract void eat();  
} 
//定义子类
   public void eat() {  
        System.out.println("吃鱼");  
    }  
}  
 

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
}

public class Test {

public static void showCatEat (Cat c){
        c.eat(); 
    }
 
    public static void showDogEat (Dog d){
        d.eat();
    }
 
    public static void showAnimalEat (Animal a){
        a.eat();
    }
    public static void main(String[] args) {
        // 多态形式，创建对象

        Cat c = new Cat();  
        Dog d = new Dog(); 
 
        // 调用showCatEat 

        showCatEat(c);
        // 调用showDogEat 

        showDogEat(d); 
 
        /*

        以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代而执行效果一致

        */

        showAnimalEat(c);
        showAnimalEat(d); 
    }
 
    
}

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。