定义

多态：同类型的多态，表现出不同的形态

多态前提：

1.有继承关系

2.有父类引用指向子类对象  Fu f = new Zi();

3.有方法的重写

调用成员

调用成员变量：编译看左边，运行也看左边

调用成员方法：编译看左边，运行看右边

为什么？

成员变量：在子类的对象中，会把父类的成员变量也继承下的。

成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。

package a02polymorphismdemo2;

public class Test {
    public static void main(String[] args) {
        //创建对象（多态方式）
        //Fu f = new Zi();
        Animal a = new Dog();
        //调用成员变量：编译看左边，运行也看左边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
        //运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
        System.out.println(a.name);//动物

        //调用成员方法：编译看左边，运行看右边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
        //运行看右边：java运行代码的时候，实际上运行的是子类中的方法。
        a.show();///Dog --- show方法

        //理解：
        //Animal a = new Dog();
        //现在用a去调用变量和方法的呀？是的
        //而a是Animal类型的，所以默认都会从Animal这个类中去找

        //成员变量：在子类的对象中，会把父类的成员变量也继承下的。父：name  子：name
        //成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。
    }
}


class Animal{
    String name = "动物";

   public void show(){
        System.out.println("Animal --- show方法");
    }
}

class Dog extends Animal{
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog --- show方法");
    }

}

class Cat extends Animal{
    String name = "猫";

   @Override
    public void show() {
        System.out.println("Cat --- show方法");
    }
}

多态的优势

方法中，使用父类型作为参数，可以接收所有子类对象

父类Person类

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 show(){

        System.out.println(name + ", " + age);
    }
}

子类Administrator类

public class Administrator extends Person {
    @Override
    public void show() {

        System.out.println("管理员的信息为：" + getName() + ", " + getAge());
    }
}

子类Teacher类

public class Teacher extends Person{

    @Override
    public void show() {

        System.out.println("老师的信息为：" + getName() + ", " + getAge());
    }
}

子类Student类

public class Student extends Person{

    @Override
    public void show() {

        System.out.println("学生的信息为：" + getName() + ", " + getAge());
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        //创建三个对象，并调用register方法

        Student s = new Student();
        s.setName("张三");
        s.setAge(18);


        Teacher t = new Teacher();
        t.setName("王建国");
        t.setAge(30);

        Administrator admin = new Administrator();
        admin.setName("管理员");
        admin.setAge(35);



        register(s);
        register(t);
        register(admin);


    }
    
    //这个方法既能接收老师，又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父类
    public static void register(Person p){
        p.show();
    }
}

运行结果：