多态

Java的四大特性，抽象，继承，封装，多态。

我对多态的理解

产生多态的三个条件

1）必须要有继承

2）子类必须重写父类的方法

3）父类的引用（实例）指向子类对象

多态又叫动态绑定，绑定在方法上（所以这里就需要重写那个产生多态的方法了）

//多态最终版
public class TestPoly {
    public static void main(String[] args) {
        Person.grown();
        Tiger tiger = new Tiger("老虎", 3,"yellow");
        System.out.println(tiger.getName()+tiger.getAge()+tiger.getColor());
        tiger.eat();  //当我们重写了父类的方法，就会表现出自己的特征
        //1.Tiger是继承Animal
        //2.Tiger类中重写了Animal中的eat()方法
        //3.父类的引用（实例），指向了子类对象
        Animal tiger1 = new Tiger("测试多态的老虎", 100, "red");
        System.out.println(tiger1.getName()+tiger1.getAge());
        //在这里就会报错，因为只有方法有多态性（方法是动态绑定），变量是静态绑定的
        //System.out.println(tiger1.getColor());
        tiger1.eat();
    }
}
class Animal{
    private String name;
    private int age;
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println("我是动物吃东西的方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Tiger extends Animal{
    
    private String color;
    public Tiger(String name, int age) {
        super(name, age);
    }
    public Tiger(String name, int age,String color) {
        super(name, age);
        this.color = color;
    }
    //本来我们可以继承到eat()方法，但是我们还是想要重新，完成子类独有的特征
    public void eat() {
        System.out.println("我是老虎类的吃东西方法");
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}