态跟属性无关，多态指的是方法的多态，而不是属性的多态

案例

public class Animal {//父类：动物：
    public void shout(){
        System.out.println("我是小动物，我可以叫。。。");
    }
}

public class Cat extends Animal{
    //喊叫方法：
    public void shout(){
        System.out.println("我是小猫，可以喵喵叫");
    }
    public void scratch(){
        System.out.println("我是小猫，我可以挠人");
    }
}

public class Dog extends Animal{
    //喊叫：
    public void shout(){
        System.out.println("我是小狗，我可以汪汪叫");
    }
    public void guard(){
        System.out.println("我是小狗，我可以看家护院，保护我的小主人。。。");
    }
}

public class Pig extends Animal{
    public void shout(){
        System.out.println("我是小猪，我嗯嗯嗯的叫");
    }
    public void eat(){
        System.out.println("我是小猪，我爱吃东西。。");
    }
}

public class Girl {
    //跟猫玩耍：
    /*public void play(Cat cat){
        cat.shout();
    }*/
    //跟狗玩耍：
    /*public void play(Dog dog){
        dog.shout();
    }*/
    //跟小动物玩耍：
    public void play(Animal an){
        an.shout();
    }
}

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //具体的猫：--》猫的对象
        //Cat c = new Cat();
        //具体的小女孩：--》女孩的对象
        Girl g = new Girl();
        //小女孩跟猫玩：
        //g.play(c);
        //具体的狗---》狗的对象：
        //Dog d = new Dog();
        //小女孩跟狗玩：
        //g.play(d);
        //具体的动物：--》动物的对象：
        //Cat c = new Cat();
        //Dog d = new Dog();
        Pig p = new Pig();
        Animal an = p;
        g.play(an);
    }
}

总结

1. 先有父类，再有子类 —> 继承

   先有子类，再有父类   --> 泛化

1. 多态

   1. 多态就是多种状态：同一个行为，不同的子类表现出来不同的形态
   2. 多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为

2. 多态的好处

   1. 为了提高代码的扩展性，符合面向对象的设计原则：开闭原则
   2. 开闭原则：指的就是扩展是 开放的，修改是关闭的

3. 多态的要素（以上代码块为例）

   1. 继承：Cat extends Animal
   2. 重写：子类对父类的方法shout()重写
   3. 父类引用指向子类对象：

Pig p = new Pig();
Animal an = p;