Java 多态（学习 Java 编程语言 043）

1. 多态

一个对象变量可以指示多种实际类型的现象被称为多态（polymorphism）。多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。

有一个简单规则可以用来判断是否应该将数据设计为继承关系，就是 “is-a” 规则，它指出子类的每个对象也是超类的对象。例如，每个经理都是员工，因此，将 Manager 类设计为 Employee 类的子类是有道理的；反之亦然，并不是每一名员工都是经理。

“is-a” 规则的另一种表述是替换原则（substitution principle），它指出程序中出现超类对象的任何地方都可以使用子类对象替换。

Employee 类：

import java.time.LocalDate;
import java.util.Objects;

public class Employee {
    private String name;
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day) {
        this.name = name;
        this.salary = salary;
        hireDay = LocalDate.of(year, month, day);
    }

    public String getName() {return name;}

    public double getSalary() {return salary;}

    public LocalDate getHireDay() {return hireDay;}

    public void raiseSalary(double byPercent) {
        double raise = salary * byPercent / 100;
        salary += raise;
    }

    @Override
    public String toString() {
        String str = "%s[name=%s, salary=%.2f, hireDay=%s]";
        return String.format(str, getClass(), name, this.getSalary(), hireDay);
    }
}

Manager 类：

public class Manager extends Employee {

    private double bonus;

    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        this.bonus = 0;
    }

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

    @Override
    public double getSalary() {
        double baseSalary = super.getSalary(); 
        return baseSalary + bonus;
    }
}

例如，可以将子类的对象赋给超类变量。

Employee e;
e = new Employee(...); // Employee object expected
e = new Manager(...); // OK, Manager can be used as well

在 Java 程序设计语言中，对象变量是多态的（polymorphic）。一个 Employee 类型的变量既可以引用一个 Employee 类型的对象，也可以应用 Employee 类的任何一个子类的对象（例如，Manager）。

利用这个替换原则：

Manager boss = new Manager("Carl Cracker", 75000, 1987, 12, 15);
Employee[] staff = new Employee[3];
staff[0] = boss;

在这个例子中，变量 staff[0] 与 boss 引用同一个对象。但编译器只将 staff[0] 看成是一个 Employee 对象。
boss 变量可以这样调用：
 boss.setBonus(50000); // 这是正确的
但不能着这样调用：
 staff[0].setBonus(50000); // 这是错误的
这是因为 staff[0] 声明的类型是 Employee，而 setBonus 不是 Employee 类的方法。
不能将超类的引用赋给子类变量。例如，下面的赋值就是非法的：
 Manager m = staff[i]; // 这是错误的
原因很清楚：不是所有的员工都是经理。如果赋值成功，m 有可能引用了一个不是经理的 Employee 对象，而后面有可能会调用 m.setBonus(…)，这就会发生运行时错误。

在 Java 中，子类引用的数组可以转换成超类引用的数组，而不需要采用强制类型转换。例如，下面是一个经理数组
 Manager[] managers = new Manager[10];
将它转换成 Employee[] 数组完全是合法的：
 Employee[] staff = managers; // OK
这样做肯定不会有问题，请思考一下其中的缘由。毕竟，如果 manager[i] 是一个 Manager，它也一定是一个 Employee。不过，实际上将会发生一些令人惊讶的事情。要切记 managers 和 staff 引用的是同一个数组。现在看一下这条语句：
 staff[0] = new Employee("Harry Hacker", . . .);
编译器竟然接纳了这个赋值操作。但在这里，staff[0] 与 manager[0] 是相同的引用，似乎我们把一个普通员工擅自归入经理行列中了。这是一种不好的情形，当调用 managers[0].setBonus(1000) 的时候，将会试图调用一个不存在的实例字段，进而搅乱相邻存储空间的内容。

为了确保不发生这类破坏，所有数组都要牢记创建时的元素类型，并负责监督仅将类型兼容的引用存储到数组中。例如，使用 new managers[10] 创建的数组是一个经理数组。如果试图存储一个 Employee 类型的引用就会引发 ArrayStoreException 异常。

2. 理解方法调用

准确地理解如何在对象上应用方法调用非常重要。下面假设要调用 x.f(args)，隐式参数 x 声明为类 C 的一个对象。下面是调用过程的详细描述：

1. 编译器査看对象的声明类型和方法名。需要注意的是：有可能存在多个名字为 f 但参数类型不一样的方法。例如，可能存在方法 f(int) 和方法 f(String)。编译器将会一一列举 C 类中所有名为 f 的方法和其超类中所有名为 f 而且可访问的方法（超类的私有方法不可访问）。

   至此， 编译器已知道所有可能被调用的候选方法。

2. 接下来，编译器要确定方法调用中提供的参数类型。如果在所有名为 f 的方法中存在一个与所提供参数类型完全匹配的方法，就选择这个方法。这个过程被称为***重载解析（ overloading resolution)***。例如，对于调用 x.f(“Hello”)，编译器将会挑选 f(String)，而不是 f(int)。由于允许类型转换（int 可以转换成 double，Manager 可以转换成 Employee，等等），所以情况可能变得很复杂。

   如果编译器没有找到与参数类型匹配的方法，或者发现经过类型转换后有多个方法与之匹配，编译器就会报告一个错误。

   至此，编译器已经知道需要调用的方法的名字和参数类型。

   方法的名字和参数列表称为方法的签名。例如，f(int) 和 f(String) 是两个有相同名字、不同签名的方法。如果在子类中定义了一个与超类签名相同的方法，那么子类中的这个方法就会覆盖超类中这个相同签名的方法。

   返回类型不是签名的一部分。不过在覆盖一个方法时，需要保证返回类型的兼容性。允许子类将覆盖方法的返回类型改为原返回类型的子类型。例如，假设 Employee 类有以下方法：
    public Employee getBuddy() {...}
   经理不会想找这种底层员工作搭档。为了反映这一点，在子类 Manager 中，可以如下覆盖这个方法：
    public Manager getBuddy() {...} // Ok to change return type
   我们说，这两个 getBuddy 方法有可协变的返回类型。

3. 如果是 private 方法、static 方法、final 方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法，这称为静态绑定（static binding )。与此对应的是，如果要调用的方法依赖于隐式参数的实际类型，那么必须在运行时使用动态绑定。在我们的示例中，编译器会利用动态绑定生成一个调用 f(String) 的指令。

4. 程序运行并且采用动态绑定调用方法时，虚拟机必须调用与 x 所引用对象的实际类型对应的那个方法。假设 x 的实际类型是 D，它是 C 类的子类。如果 D 类定义了方法 f(String)，就会调用这个方法；否则，将在 D 类的超类型中寻找 f(String)，以此类推。

每次调用方法都要完成这个搜索，时间开销相当大。因此，虚拟机预先为每个类计算了一个***方法表（method table）***，其中列出了所有方法的签名和要调用的实际方法。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。在前面的例子中，虚拟机搜索 D 类的方法表，寻找与调用 f(String) 相匹配的方法。这个方法既有可能是 D.f(String)，也有可能是 X.f(String)，这里的 X 是 D 的某个超类。这里需要提醒一点，如果调用的是 super.f(param)，那么编译器将对隐式参数超类的方法表进行搜索。

现在详细分析调用 e.getSalary() 的过程。e 声明为 Employee 类型。Employee 类只有一个叫 getSalary 的方法，这个方法是没有参数。因此这里不必担心重载解析的问题。

由于 getSalary 不是 private 方法、static 方法或 final 方法，所有将采取动态绑定。虚拟机为 Employee 和 Manager 类生成方法表，在 Employee 的方法表中列出了这个 Employee 类本身定义的所有方法：

    Employee:
        getName() -> Employee.getName()
        getSalary() -> Employee.getSalary()
        getHireDay() -> Employee.getHireDay()
        raiseSalary(double) -> Employee.raiseSalary(double)
        toString() -> Employee.toString()

实际上，上面列出的方法并不完整，Employee 类有一个超类 Object，Employee 类从这个超类中还继承了大量方法，在此，我们略去了 Object 方法。

Manager 方法表稍微有些不同。其中有三个方法是继承而来的，一个方法是重新定义的，还有一个方法是新增的。

    Manager:
        getName() -> Employee.getName()
        getSalary() -> Manager.getSalary()
        getHireDay() -> Employee.getHireDay()
        raiseSalary(double) -> Employee.raiseSalary(double)
        setBonus(double) -> Manager.setBonus(double)
        toString() -> Employee.toString()

在运行时，调用 e.getSalary() 的解析过程为：

1. 首先，虚拟机获取 e 的实际类型的方法表。这可能是 Employee、Manager 的方法表，也可能是 Employee 类的其他子类的方法表。
2. 接下来，虚拟机查找了定义了 getSalary() 签名的类。此时，虚拟机已经知道应该调用哪个方法。
3. 最后，虚拟机调用这个方法。

动态绑定有一个非常重要的特性：无需对现有的代码进行修改就可以对程序进行扩展。假设增加一个新类 Programmer，Programmer 是 Employee 类派生出的子类，并且变量 e 有可能引用这个类的对象，我们不需要对包含调用 e.getSalary() 的代码进行重新编译。如果 e 恰好引用一个 Programmer 类的对象，就会自动地调用 Programmer.getSalary() 方法。

警告： 在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。特别是，如果超类方法是 public，子类方法必须也要声明为 public。经常会发生这类错误：即子类方法不小心遗漏了 public 修饰符。此时，编译器就会报错，指出你试图提供更严格的访问权限。