java面向对象之多态

多态的概念
同一对象不同时刻表现出的不同形态，发生在继承或者实现的前提下。比如，动物某些场景指的是猫，某种场景下指的是狗。

//定义一个父类Animal
public class Animal {
    String name;
    public int age = 40;

    public Animal() {
    }

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

    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;
    }
    public void eat(){
        System.out.println("吃东西");
    }
}
//定义子类Cat
public class Cat extends Animal{
    public int age = 20;
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
//定义子类Dog
public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
}
//定义测试类
public class Test01 {
    public static void main(String[] args) {
        Animal cat = new Cat(); //多态表现为猫
        Animal dog = new Dog(); //多态表现为狗
    }
}

多态的成员访问特点

成员变量：编译看父类，运行看父类

public class Test01 {
    public static void main(String[] args) {
        Animal cat = new Cat(); //多态表现为猫
        System.out.println(cat.age);
    }
}
输出结果：
40

成员方法：编译看父类，运行看子类

public class Test01 {
    public static void main(String[] args) {
        Animal cat = new Cat(); //多态表现为猫
        cat.eat();
    }
}
输出结果：
猫吃鱼

多态中的转型
向上转型（父类引用子类对象）
向下转型（父类引用转为子类对象）

public class Cat extends Animal{
    public int age = 20;
    public Cat() {
    }

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

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫玩游戏");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Animal cat = new Cat(); //向上转型
        cat.eat();
        Cat c = (Cat) cat;// 向下转型
        c.playGame();
    }
}

多态的好处和弊端：
提高程序的扩展性，缺点父类不能引用子类特有的成员方法和变量