Java中的多态和动态绑定

更多2019年的技术文章，欢迎关注我的微信公众号：码不停蹄的小鼠松（微信号：busy_squirrel），也可扫下方二维码关注获取最新文章哦~

###　1. 定义

根据Core Java：

1. **多态：**一个对象变量可以指示多种实例类型的现象。

2. **动态绑定：**在运行时刻能够自动选择调用哪个方法的现象。
3. **签名：**方法名和参数列表构成一个签名

多态和动态绑定大多与继承有关，因为有了继承的出现，才有了父类与子类，然后就是随之而来的方法重写(override)，即子类重写父类的方法。另一个出现的就是子类对象的引用转换为父类对象的引用（此处不需要进行强制转换）。比如：

    public class Son extends Father {
        ...
        
        public static void main(String []args) {
            // 第一种写法
            Son son1 = new Son();
            Father father1 = son1;
            
            // 第二种写法，两种写法类似
            Father father2 = new Son(); // 直接把创建的子类对象的引用赋值给父类变量
        }
    }
    
    

上述代码中的父类变量father1引用的是子类的对象。也就是说，father1余son1引用的都是同一个对象，这个对象就是Son类的对象。但对于变量father1来说，编译器会把其当做Father类的变量，但是JVM当中，把确认其真实的实例类型（Son类）。

子类转为父类可以，但是反过来不行，比如：

    Father father3 = new Father();
    Son son3 = father3;

此处是把父类创建的一个对象(father3)的引用赋给子类变量(son3)，在继承当中，这是不被允许的。试想：若此赋值语句成功，那么son3引用的对象其实是father3，但是son3其本身又被声明为Son类，此时在Son类中若有一个额外的新方法(eg: MethodOfSon(){…})，那么son3就可以调用该方法，但是其引用的对象是没有这个方法的，会造成混乱，所以此赋值方式不合适。

在类的继承之外，还有同一个类内部的方法重载（overloading），同一个方法名，因参数类型和参数个数不同，构成不同的签名。另外，签名不包含返回类型。

2. Example

Employee.java

    public class Employee
    {
       private String name;
       private double salary;
       private Date hireDay;
    
       public Employee(String n, double s, int year, int month, int day)
       {
          name = n;
          salary = s;
          GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
          hireDay = calendar.getTime();
       }
    
       public String getName()
       {
          return name;
       }
    
       public double getSalary()
       {
          return salary;
       }
    
       public Date getHireDay()
       {
          return hireDay;
       }
    
       public void raiseSalary(double byPercent)
       {
          double raise = salary * byPercent / 100;
          salary += raise;
       }
    }

Manager.java

    public class Manager extends Employee
    {
       private double bonus;
    
       /**
        * @param n the employee's name
        * @param s the salary
        * @param year the hire year
        * @param month the hire month
        * @param day the hire day
        */
       public Manager(String n, double s, int year, int month, int day)
       {
          super(n, s, year, month, day);
          bonus = 0;
       }
    
       public double getSalary()
       {
          double baseSalary = super.getSalary();
          return baseSalary + bonus;
       }
    
       public void setBonus(double b)
       {
          bonus = b;
       }
    }

ManagerTest.java

    public class ManagerTest
    {
       public static void main(String[] args)
       {
          // construct a Manager object
          Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
          boss.setBonus(5000);
    
          Employee[] staff = new Employee[3];
    
          // fill the staff array with Manager and Employee objects
    
          staff[0] = boss;
          staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
          staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
          
          
          // print out information about all Employee objects
          for (Employee e : staff)
             System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
       }
    }

其结果如下：

name=Carl Cracker,salary=85000.0
name=Harry Hacker,salary=50000.0
name=Tommy Tester,salary=40000.0

说明类Manager继承类Employee，在Manager内部重写了getSalary()方法，并新添加了setBonus()方法。

在main()函数中，Employee类型的数组staff包含了3个元素，第一个元素staff[0]包含的Manager类对象的引用，其与boss引用同一个Manager对象。staff[1]和staff[2]包含的是Employee类变量，分别指向不同的Employee类对象。

从结果看出，staff[0]的getSalary()方法，调用的Manager里面的方法，而staff[1]和staff[2]都是调用的Employee类中的getSalary()方法。staff[0]虽然声明的是一个Employee变量，但是其引用的对象却是Manager类对象，所以会首先在Manager类中查找是否有完全匹配的getSalary()方法（有可能存在重载的情况），然后再在父类中查找是否有完整的getSalary()方法。

还一个需要注意的地方：编译器会认为staff[0]是一个Employee对象，所以对于以下的调用方式，程序会出错：

    staff[0].setBonus(100);

同样，如果有如下的赋值，也是错误的：

    Manager manager1 = staff[0];

因为从编译器的角度来看，这两个是不同的类型，所以需要进行强制类型转换：

    Manager manager1 = (Manager) staff[0];

这种方式，看似这样很合理，因为staff[0]引用的是Manager对象，让manager1变量也应用这个对象，这样赋值好像也没什么不对，但是同样编译器报错。因为编译器认为staff[0]是属于Employee类型的，而Manager类是Employee类的子类，两者是不同的类型，不能直接赋值，必须要强制类型转换。

按照这个逻辑，以下的赋值语句，编译器也是通过的：

    Manager manager2 = (Manager) staff[1];

虽然编译器是通过的，但是在程序运行时，也会报错"ClassCastException"。原因在于staff[1]引用的对象是Employee类型的，也就是说，该Employee对象也能调用子类Manager当中的新方法$setBonus(x)$，这是错误的。所以，Java当中，把父类对象强制转换为子类对象是不被允许的，反过来可以。

其实，上面的一段话，是从底层的角度对多个对象的逻辑关系进行的分析，实际上，Java虚拟机已经帮我们做了安全检查。只需要使用$instanceof$运算符，就可以确保赋值安全。

    Manager manager2;
    if(staff[1] instanceof Manager) {
        manager2 = staff[1];
    }

所以，***在将超类对象转为子类对象时，一定要进行$instanceof$检查***。

在上面的例子中，staff[0]就是一个多态的例子，有继承，就有多态。和多态分不开的一个就是动态绑定。动态绑定和是静态绑定相对应的，一个是在编译的时候就知道用什么方法，还一个就是在运行时刻才知道调用哪个方法。

有private，static，final修饰的方法，或者构造函数，都是静态绑定。

3. 动态绑定的内部机制

首先理解方法表的概念：

方法表：除了private、static、final修饰的方法外，其他的能够参与动态绑定的实例方法。

对于动态绑定来说，每次在类中找对应的方法总是低效的，时间开销大，所以需要为每个类生成一个方法表，这样可以直接在类的方法表中寻找。

过程如下：

1. 首先编译器确定对象的声明类型和方法名。然后找当前类中方法名字匹配的所有方法（由于重载，可能存在多个），然后在其父类中也找类似的属性为public的方法；
2. 编译器查看调用方法的参数类型，先在本类中找，然后在超类中找，这一过程称为***重载解析(overloading resolution)***。若没找到，或在同一个类中找到多个，均报错。
3. 若为private、static或者final修饰的方法，为静态绑定，可直接知道调用的是哪个方法，此情况下就省去了剩下的步骤；
4. 在程序运行时，JVM会根据对象的实际类型从方法表中调用最合适的方法。

note：

• 动态绑定只针对类的方法，对数据域无效，因为根据类的封装特性，数据域都是私有的，即使是子类，也无法访问。
• 方法表存储在JVM中的方法区。

参考：

• http://blog.csdn.net/sureyonder/article/details/5569617
• http://www.cnblogs.com/ericdream/archive/2012/01/07/2315697.html

\qquad \qquad \qquad \qquad —— 2016.5.31

更多2019年的技术文章，欢迎关注我的微信公众号：码不停蹄的小鼠松（微信号：busy_squirrel），也可扫下方二维码关注获取最新文章哦~