Java动态绑定机制

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

即调用的方法先看运行类型中有没有，只要有就调用（无论是函数中再次调用还是直接调用，只要是函数），没有，才在父类中找。

2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

Java多态的应用：

（1）多态数组：声明数组时，数组的元素对象为父类，实际存储的时候，可以存放子类，如果父子类都有相同的方法，则运行时可以实现多态。

如果想要调用子类独有的方法，可以使用instanceof来判断是否为子类类型，然后进行强转向下转型，再调用。

例如：

package poly_polyarr;

public class Person {//父类
    String name;
    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;
    }
}

package poly_polyarr;

public class Student extends Person{
    private double score;

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

    public String say(){
        return super.say()+" score:"+score;
    }
    public void study(){
        System.out.println(name+"学习");
    }
}

package poly_polyarr;

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;
    }

    public String say(){
        return super.say()+" salary:"+salary;
    }

    public void teach(){
        System.out.println(name+":讲课");
    }
}

package poly_polyarr;

public class PolyArr {
    public static void main(String[] args) {
        Person[] persons = new Person[5];
        persons[0] = new Person("jack",29);
        persons[1] = new Student("j",2,100);
        persons[2] = new Student("a",3,1);
        persons[3] = new Teacher("t1",2,20000);
        persons[4] = new Teacher("t2",3,10000);
        for(Person p:persons){
//            System.out.println(p.say());
            if(p instanceof Student){
                ((Student) p).study();
            }else if(p instanceof Teacher){//判断运行类型是否是teacher类或者其子类
                ((Teacher) p).teach();
            }else{
                System.out.println("类型有误");
            }
        }
    }
}

（2）多态参数：在函数声明时，形参声明为父类型，传参的时候可以子类的对象，实现多态

package poly_parameter;

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;
    }
}

package poly_parameter;

public class Woker extends Employee{
    public Woker(String name, double salary) {
        super(name, salary);
    }

    public void work(){
        System.out.println(getName()+"work！");
    }

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

package poly_parameter;

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()+"is manager");
    }

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

package poly_parameter;

public class Test {
    public static void main(String[] args) {
        Woker tom = new Woker("tom", 2000);
        Manager qq = new Manager("qq", 10000, 100);
        Test test = new Test();
        test.showEmpAnnual(tom);
        test.showEmpAnnual(qq);
        test.testWork(tom);
        test.testWork(qq);
    }

    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());
    }

    public void testWork(Employee e){
        if(e instanceof Woker){
            ((Woker) e).work();
        }else if(e instanceof Manager){
            ((Manager) e).manage();
        }
    }
}