这里说明动态绑定，但涉及到方法重写（先忽略这个问题）。
以下是三个类，两个子类一个超类，重点关注每个类中的eat方法.

//Dog.java
class Dog extends Animal{

    public static Dog Init(String name,int age){
        Dog dog = new Dog(name,age);
        return dog;
    }
    public Dog(String name,int age){
        super(name,age);
    }

    //关注eat方法
    @Override
    public void eat() {
        System.out.println(this.name+" 正在吃狗粮.......");
    }
}

//Animal.java
class Animal {
    String name;
    int age;

    public Animal(String name,int age){
        this.name=name;
        this.age =age;
    }

    public static void fun(Animal animal){
        animal.eat();
    }
    //关注eat方法
    public void eat(){
        System.out.println(this.name + "正在吃饭。");
    }

}

//Bird.java
class Bird extends Animal{
    public static Bird Init(String name,int age){
        Bird bird = new Bird(name,age) ;
        return bird;
    }

    public Bird(String name,int age){
        super(name,age);
    }
    //关注eat方法
    @Override
    //eren jeger
    public void eat() {
        System.out.println(this.name+" 正在吃虫子.......");
    }
}

????接下来来分析Main类了

public class Main {

    public static void main(String[] args) {
        Animal animal= Dog.Init("kunkun",1);
        animal.eat();//这里的eat调用的是哪个类里面eat方法？
    }
}

调用的是子类Dog，为什么呢？这里不是向上转型成Animal(超类)了吗？
嗯，这里就得介绍本标题的主角：动态绑定机制

1. 动态绑定机制，简单来说，以父类为编译类型，创建子类对象的时候，绑定子类运行类型，当我们再调用方法的时候，能够有序的寻找方法，实现方法的有序调用。
2. 解释：1.动态绑定机制在运行时调用方法绑定子类运行。
   2.程序在编译时，确实调用的时父类的eat方法。当运行代码的时候，通过父类的引用，调用了父类和子类重写的方法，结果实际调用了子类的方法，此时称这种情况为动态绑定。
   3.程序运行并且采用动态绑定调用方法时,JVM会调用父类所引用对象的实际类型的方法。
   三种解释任选理解。下面来说明方法重写。