调用方法时，只要方法重写了。实际调用哪个方法，要看实际调用哪个对象。

• 动态绑定是指"在执行期间（而非编译期）"判断引用对象的实际类型，根据其实际的类型调用其相应的方法。

class Animal {
    private String name;
    Animal (String name) {
        this.name = name;
    }
    public void enjoy() {
        System.out.println("叫声...");
    }
}

class Cat extends Animal {
    public String eyesColor;
    Cat(String n,String c) {
        super(n); eyesColor = c;
    }
    public void enjoy() {
        System.out.println("猫叫声...");
    }
}

class Dog extends Animal {
    public String furColor;
    Dog(String n, String c) {
        super(n); furColor = c;
    }
    public void enjoy() {
        System.out.println("狗叫声...");
    }
}

class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {
        this.name = name; this.pet = pet;
    }
    public void myPetEnjoy() {
        pet.enjoy();
    }

}
public class Test {
    public static void main(String[] args) {
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname","black");
        
        Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        
        l1.myPetEnjoy();  // 猫叫声...
        l2.myPetEnjoy(); //  狗叫声...
    }
}

多态的存在要有三个必要条件：

1. 要有继承
2. 要有重写
3. 父类引用指向子类对象

new是哪个子类对象实际调用的就是哪个子类对象

抽象类

• 用abstract 关键字来修饰一个类时，这个类叫做抽象类；
  用abstract来修饰一个方法时，该方法叫做抽象方法
• 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
• 抽象类不能被实例化
• 抽象方法只需声明，而不需实现

abstract class Animal {
    private String name;
    Animal (String name) {
        this.name = name;
    }
    public  abstract void  enjoy() ;
}

class Cat extends Animal {
    public String eyesColor;
    Cat(String n,String c) {
        super(n); eyesColor = c;
    }
        public void enjoy() {
        System.out.println("猫叫声...");
    }
}