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(this.name+"吃东西");
    }
}

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

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

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

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

public class Test {
    public static void main(String[] args) {
        Animal cat=new Cat("咪咪",2);//这里发生向上转型
        Animal dog=new Dog("旺财",1);//向上转型

        //cat、dog为父类类型的引用
        cat.eat();
        dog.eat();

    }
}

输出结果：

在主函数里面，cat和dog都是父类类型的引用，分别都调用了父类中的eat()方法，但是最后所表现出的状态却不一样，在这里就体现了多态。

2.2 动态绑定

以上代码的输出结果可能有些人不太理解，明明调用的好像是父类中的eat()方法，但是最后表现出来的却像是调用子类的eat()方法呢？在这里其实发生了动态绑定。所谓动态绑定，引用究竟引用哪一个方法是在运行时才能确定的。在编译时不能确定（编译就能确定引用调用哪个方法的就静态绑定）。动态绑定经常发生在多态中，就像上面的代码一样。父类引用指向一个子类对象时，调用的函数是被子类重写过的函数时就会发生动态绑定，此时引用虽然调用的像是父类的方法，实际上最后调用的是子类重写父类方法后的方法。

这就是由继承和向上转型所引发的多态，在下面再给大家仔细串一下发生多态整个过程：

首先是在继承机制下，子类会重写父类的某些方法，然后定义一个父类类型的引用，这个引用指向了子类对象。当这个引用去调用父类中被子类重写了的方法时，就会发生动态绑定。最后调用的是子类中重写父类的方法。

3、多态的优缺点

优点1：能够降低代码的“圈复杂度”，避免使用大量的if-else。

什么是圈复杂度？圈复杂度是一种描述代码复杂程度的方式。一段代码如果平铺直叙，就很容易理解，如果有大量的分支或循环，就认为理解起来较为复杂。

因此我们可以大致的计算一下一段代码中条件语句和循环语句中出现的个数，这个个数就称为圈复杂度。如果一个方法的圈复杂度太高，则一般要考虑重构。

不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10。

比如我们现在要打印多个图案，如果不用多态，则可以写成以下这个样子：

class Cycle{

    public void draw() {
        System.out.println("●");
    }
}
class  Triangle{

    public void draw() {
        System.out.println("△");
    }
}
class Flower{

    public void draw() {
        System.out.println("?");
    }
}
public class Test1 {
    public static void drawing(){
        Cycle cycle=new Cycle();
        Triangle triangle=new Triangle();
        Flower flower=new Flower();
        String[] shapes = {"cycle", "triangle", "flower"};
        for (String shape : shapes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("triangle")) {
                triangle.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
        }
    }
    public static void main(String[] args) {
        drawing();
    }
}

运行结果：

如果用多态的思想来解决这个问题，则可以写成以下代码：

class A{
    public  void draw(){
        System.out.println("画东西");
    }
  
}
class Cycle extends A{

    @Override
    public void draw() {
        System.out.println("●");
    }
}
class  Triangle extends A{
    @Override
    public void draw() {
        System.out.println("△");
    }
}
class Flower extends A{
    @Override
    public void draw() {
        System.out.println("?");
    }
}
public class Test {
    public static  void func(A a){
        a.draw();

    }
    public static void main(String[] args) {

        A cycle=new Cycle();
        A triangle=new Triangle();
        A flower=new Flower();
        func(cycle);
        func(triangle);
        func(flower);
        cycle.funccc();
    }
}

运行结果：

很显然，两个代码实现的功能一样，但第二个代码使用多态来实现需求，使代码的可读性更高，简单明了，更易理解。

优点2：可扩展能力更强。如果我们想在以上的代码中增加一种需求，比如再画个☆，使用多态的方式来改动代码，成本会更低，只需要加入：