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 的一个对象。下面是调用过程的详细描述：
-
编译器査看对象的声明类型和方法名。需要注意的是：有可能存在多个名字为 f 但参数类型不一样的方法。例如，可能存在方法 f(int) 和方法 f(String)。编译器将会一一列举 C 类中所有名为 f 的方法和其超类中所有名为 f 而且可访问的方法（超类的私有方法不可访问）。
至此， 编译器已知道所有可能被调用的候选方法。
-
接下来，编译器要确定方法调用中提供的参数类型。如果在所有名为 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 方法有可协变的返回类型。
如果是 private 方法、static 方法、final 方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法，这称为静态绑定（static binding )。与此对应的是，如果要调用的方法依赖于隐式参数的实际类型，那么必须在运行时使用动态绑定。在我们的示例中，编译器会利用动态绑定生成一个调用 f(String) 的指令。
程序运行并且采用动态绑定调用方法时，虚拟机必须调用与 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() 的解析过程为：
- 首先，虚拟机获取 e 的实际类型的方法表。这可能是 Employee、Manager 的方法表，也可能是 Employee 类的其他子类的方法表。
- 接下来，虚拟机查找了定义了 getSalary() 签名的类。此时，虚拟机已经知道应该调用哪个方法。
- 最后，虚拟机调用这个方法。
动态绑定有一个非常重要的特性：无需对现有的代码进行修改就可以对程序进行扩展。假设增加一个新类 Programmer，Programmer 是 Employee 类派生出的子类，并且变量 e 有可能引用这个类的对象，我们不需要对包含调用 e.getSalary() 的代码进行重新编译。如果 e 恰好引用一个 Programmer 类的对象，就会自动地调用 Programmer.getSalary() 方法。
警告： 在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。特别是，如果超类方法是 public，子类方法必须也要声明为 public。经常会发生这类错误：即子类方法不小心遗漏了 public 修饰符。此时，编译器就会报错，指出你试图提供更严格的访问权限。
