Java中的多态和动态绑定

　1 定义

Example

动态绑定的内部机制

　1. 定义

根据Core Java：

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

动态绑定：在运行时刻能够自动选择调用哪个方法的现象。

签名：方法名和参数列表构成一个签名

多态和动态绑定大多与继承有关，因为有了继承的出现，才有了父类与子类，然后就是随之而来的方法重写(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修饰的方法外，其他的能够参与动态绑定的实例方法。

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

过程如下：

首先编译器确定对象的声明类型和方法名。然后找当前类中方法名字匹配的所有方法（由于重载，可能存在多个），然后在其父类中也找类似的属性为public的方法；

编译器查看调用方法的参数类型，先在本类中找，然后在超类中找，这一过程称为重载解析(overloading resolution)。若没找到，或在同一个类中找到多个，均报错。

若为private、static或者final修饰的方法，为静态绑定，可直接知道调用的是哪个方法，此情况下就省去了剩下的步骤；

在程序运行时，JVM会根据对象的实际类型从方法表中调用最合适的方法。

note：

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

方法表存储在JVM中的方法区。

参考：

http://blog.csdn.net/sureyonder/article/details/5569617

http://www.cnblogs.com/ericdream/archive/2012/01/07/2315697.html

—— 2016.5.31