动态绑定机制

（1）当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。

（2）当调用对象属性的时候，没有动态绑定机制，在哪里声明就在哪使用。

案例

public class DynamicBinding {
    public static void main(String[] args) {
        //编译类型为X，运行类型为Y
        X x = new Y();//向上转型

        System.out.println(x.sum());//30
        //当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
        //所以在X类sum()方法中调用getCount()方法是Y类的getCount()

        System.out.println(x.sum1());//20
        //当调用对象属性的时候，没有动态绑定机制，在哪里声明就在哪使用
        //所以count就是X类中的count
    }
}

class X {
    public int count = 10;

    public int getCount() {
        return count + 10;
    }

    public int sum() {
        return getCount() + 10;
        //动态绑定机制，getCount()是Y类中的
    }

    public int sum1() {
        return count + 10;
    }
}

class Y extends X {
    public int count = 20;

    public int getCount() {
        return count;
    }
}

多态的应用

多态数组

//数组的编译类型为父类类型，里面保存的实际元素为子类类型
public class PolymorphicArray {
    public static void main(String[] args) {
        //应用实例：现有一个继承结构如下：
        //要求创建1个Person对象，2个Student对象和2个Teacher对象
        //统一放在数组中，并调用每个对象的say方法

        Person[] persons = new Person[5];
        persons[0] = new Person("zxm", 18);
        persons[1] = new Student("zxm", 18, 99);
        persons[2] = new Student("lqh", 18, 100);
        persons[3] = new Teacher("jack", 30, 20000);
        persons[4] = new Teacher("tom", 35, 25000);

        //循环遍历多态数组，调用say方法
        for (int i = 0; i < persons.length; i++) {

            System.out.println(persons[i].say());//动态绑定机制
            //persons[i] 的编译类型是Person，运行类型根据实际情况，由JVM来判断

            //调用类中特定方法,不能直接调用，因为是类中的特定方法
//            persons[i].study();//会报错
//            persons[i].teach();//会报错

            //需要进行判断
            if (persons[i] instanceof Student) {
                Student student = (Student) persons[i];//向下转型
                student.study();
                //也可以使用一条语句((Student) person[i]).study(); 进行调用
            } else if (persons[i] instanceof Teacher) {
                Teacher teacher = (Teacher) persons[i];//向下转型
                teacher.teach();
                //也可以使用一条语句((Student) person[i]).teach(); 进行调用
            }
        }
    }
}

//Person类存放信息
public class Person {
    private String name;
    private int age;

    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 String say() {
        return "name=" + name + " age=" + age;
    }
}

//Student类存放学生特有属性
public class Student extends Person{
    private double score;

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String say() {
        return super.say() + " score=" + score;
    }

    public void study() {
        System.out.println("学生 " + getName() + " 正在学习");
    }
}

//Teacher类存放老师特有属性
public class Teacher extends Person{
    private double salary;

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String say() {
        return super.say() + " salary=" + salary;
    }

    public void teach() {
        System.out.println("老师 " + getName() + " 正在讲课");
    }
}

 多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型。

例题：

定义员工类Employee，包含姓名和月工资[private]，以及计算年工资getAnnual的方法。 普通员工和经理继承员工，经理类多了奖金bonus属性和管理manage方法，普通员工多了work方法， 普通员工类和经理类要求分别重写getAnnual方法

测试类中添加一个方法showEmployeeAnnual(Employee e)，实现获取任何员工对象的年工资， 并在main方法中调用该方法[e.getAnnual()]

测试类中添加一个方法，testWork，如果是普通员工，则调用work方法，如果是经理则调用manage方法

代码

编写Employee类，代表员工类

public class Employee { //员工类
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getAnnual() {
        return salary * 12;
    }
}

再编写Staff类，代表普通员工，并继承员工类

public class Staff extends Employee{ //普通员工类

    public Staff(String name, double salary) {
        super(name, salary);
    }

    public void work() {
        System.out.println("员工 " + getName() + " 正在工作");
    }

    @Override
    public double getAnnual() {
        return super.getAnnual();
    }
}

编写Manager类，代表经理，并继承员工类

public class Manager extends Employee{ //经理类

    private double bonus;

    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public void manage() {
        System.out.println("经理 " + getName() + " 正在管理员工");
    }

    @Override
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}

编写PolymorphicParameter进行测试

public class PolymorphicParameter {
    public static void main(String[] args) {
        Staff staff = new Staff("zxm", 5000);
        Manager manager = new Manager("lqh", 10000, 25000);
        PolymorphicParameter polymorphicParameter = new PolymorphicParameter();
        polymorphicParameter.showEmployeeAnnual(staff);
        polymorphicParameter.showEmployeeAnnual(manager);

        polymorphicParameter.testWork(staff);
        polymorphicParameter.testWork(manager);
    }

    public void showEmployeeAnnual(Employee e) {
        System.out.println(e.getAnnual());//动态绑定
    }

    public void testWork(Employee e) {
        if(e instanceof Staff) {
            ((Staff) e).work();//向下转型
        } else if(e instanceof Manager) {
            ((Manager) e).manage();//向下转型
        }
    }
}

查看最后输出结果

​​