5.1 类、超类和子类
子类比超类拥有的功能更加丰富。
在本例中，Manager类比超类Employee封装了更多的数据，拥有更多的功能。
在Manager类中，增加了一个用于存储奖金信息的域，以及一个用于设置这个域的方法：
class Manager extends Employee
{
private double bonus;
...
public void setBouns(double b)
{
bonus = b;
}
}
如果有一个Manager对象，就可以使用setBonus方法。
Manager boss = ... ; boss.setBonus(5000);
由于setBonus方法不是在Employee类中的定义，所以属于Employee类的对象不能使用它。
从超类中还继承了name、salary和hireDay这3个域，所以现在就有了4个域（由于增加了bonus域）。
在通过扩展超类定义子类的时候，仅需要指出子类和超类的不同之处，因此，会将通用的方法放在超类中，而将具有特殊用途的方法放在子类中，这种将通用的功能放在超类的方法，在面向对象程序设计中十分普遍。
超类中的有些方法在子类Manager中不一定适用，比如说Manager中的getSalary方法应该返回薪水和奖金的总和，为此需要提供一个新的方法来覆盖（override）超类中的这个方法。
class Manager extends Employee
{
...
//这个方法是错误的
public double getSalary()
{
return salary + bonus;
}
...
}
由于Manager类的getSalary方法不能直接地访问超类的私有域。尽管每个Manager对象都拥有一个名为salary的域，但在Manager类的getSalary方法中并不能直接访问salary域。只有Employee类的方法才能够访问私有部分。如果Manager类的方法一定要访问私有域，就必须借助公共的接口，Employee类中的公有方法getSalary就是这个公共接口。
public double getSalary()
{
//通过子类的getSalary方法不能获得超类的salary域
//所以以下这种方式也是错误的
double baseSalary = getSalary();
return baseSalary + bonus;
}
为了获取salary域，就必须要调用超类Employee中的getSalary方法，而不是当前类的这个方法。
为了调用超类Employee中的getSalary方法，而不是当前类的getSalary，必须使用super关键字来解决这个问题：
public double getSalary()
{
double baseSalary = super.getSalary();
return baseSalary + bonus;
}
在子类中可以增加域、增加方法或覆盖超类的方法，然而绝对不能删除继承的任何域和方法。
public Manager(String n, double s, int year, int month, int day)
{
super(n, s, year, month, day);
bonus = 0;
}
这里的super语句super(n, s, year, month, day)是“调用超类Employee中含的n、s、year、month和day参数的构造器”的简写方式。
由于Manager类的构造器不能访问Employee类的私有域，所以必须利用Employee类的构造器对这部分私有域进行初始化，我们可以通过super实现对超类构造器的调用。使用super调用构造器的语句必须是子类构造器的第一条语句。
综上，super的作用：
1、调用超类的方法；
2、调用超类的构造器。（调用构造器的语句只能作为另一个构造器的第一个语句出现）
重新定义Manager对象的getSalary方法之后，奖金就会自动添加到经理的薪水中。
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(50000);
接下来定义一个包含3个雇员的数组，将经理和雇员的信息都放在数组中：
Employee[] staff = new Employee[3];
staff[0] = boss;
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
for(Employee e:staff)
{
System.out,println(e.getName() + " " + e.getSalary());
}
这里staff[1]和staff[2]仅输出基本薪水，这是因为它们对应的是Employee对象，而staff[0]对应的是Manager对象，它的getSalary方法将奖金和基本薪水加在了一起。
在这里将e声明为Employee类型，但实际上它既可以引用Employee类型的对象，也可以引用Manager类型的对象。当e引用Employee对象的时候，e.getSalary()调用的是Manager类中getSalary方法，当e引用Manager对象的时候，e.getSalary()调用的是Manger类中的getSalary方法。
虚拟机知道e实际引用的对象类型，因此能够正确地调用相应的方法。
一个对象变量可以指示多种实际类型的现象被称为多态（polmorphism）。在运行时能够自动选择调用哪个方法的现象称为动态绑定（dynamic binding）。
Employee.java
package inheritance;
import java.util.Date;
import java.util.GregorianCalendar;
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 calender = new GregorianCalendar(year, month - 1, day);
hireDay = calender.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/10;
salary += raise;
}
}
Manager.java
package inheritance;
public class Manager extends Employee
{
private double bonus;
//其余的参数会从Employee继承来
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
package inheritance;
public class MangerTest {
public static void main(String args[])
{
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
Employee[] staff = new Employee[3];
staff[0] = boss;
staff[1] = new Employee("Harry Cracker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
for(Employee e:staff)
{
System.out.println("name = " + e.getName() + ",salary = " + e.getSalary());
}
}
}
5.1.1 继承层次
Java是不允许“实现多继承”，简称不允许“多继承”。但是Java支持“声明多继承”——Java的接口的多继承——一个类可以实现多个接口（“继承”了多个接口上的方法声明），而一个接口可以继承多个接口（同样是“继承”了多个接口上的方法声明）。
5.1.2 多态
可以将一个子类的对象赋值给超类变量。
对象变量是多态的，一个Employee变量既可以引用一个Employee对象，也可以引用一个Employee类的任何一个子类的对象（例如Manager类）。
Manager boss = new Manager(...); Employee[] staff = new Employee[3]; staff[0] = boss;
在这个例子中，staff[0]和boss引用的是同一个对象，但编译器将staff[0]看成Employee对象。所以以下调用方式是正确的：
boss.setBonus(5000);
但下面这种调用方式是错误的：
staff[0].setBonus(5000);
这是因为staff[0]声明的类型是Employee，而setBonus方法是Manager类的方法，不是Employee类的方法。
可以将一个子类变量赋给一个超类变量，但不能将一个超类变量赋给一个子类变量。
5.1.3 动态绑定
调用方法的过程可以分解为：
（1）编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数x声明为C类的对象。有可能存在多个名字为f，但参数不一样的方法。例如可能存在方法f(int)和f(Stirng)，编译器会一一列举所有C类中名为f的方法和其超类中访问属性为private且名为f的方法（超类的私有方法不可访问）。至此，编译器已获得所有可能被调用的候选方法。
（2）编译器查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，就选择这个方法这个过程被称为重载解析（overloading resolution）。例如，对于调用x.f("Hello")来说，编译器将会挑选f(String)，而不是f(int)。
方法签名：方法的名字和参数列表称为方法的签名。
（3）如果是private方法、static方法、final方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法，我们讲这种方法称为静态绑定（static binding）。与此对应的是，调用的方法依赖于隐式参数的实际类型，并且在运行时实现动态绑定。
（4）程序运行而且采用动态绑定调用方法的时候，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。假设x的实际类型是D，它是C类的子类，如果D类定义了一个方法f(String)，就直接调用它，否则就在D类的超类中寻找f(String)方法，以此类推。
每次调用方法的时候都要进行搜索，时间开销很大，所以虚拟机预先为每个类创建了一个方法表（method table），其中列出了所有方法的签名和实际调用的方法，当需要调用方法的时候，虚拟机查找这个表就可以了。
对于之前的e.getSalary()，e声明为Employee类型，由于这个方法没有参数，所以不需要担心方法重载的问题。
方法重载（method overload）的具体规范 如果有两个方法的方法名相同，但参数不一致，那么可以说一个方法是另一个方法的重载。 一.方法名一定要相同。 二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。 1.如果参数个数不同，就不管它的参数类型了！ 2.如果参数个数相同，那么参数的类型或者参数的顺序必须不同。 三.方法的返回类型、修饰符可以相同，也可不同。 四.main方法也可以被重载 方法重载的作用：可以一个相同的方法传入不同的参数以达到想要的结果
所以，e.getSalary()执行的过程如下：
（1）虚拟机提取e的实际类型的方法表，即可能是Employee、Manager的方法表，也可能是Employee类的其他子类的方法表；
（2）虚拟机搜索定义getSalary签名的类，此时，虚拟机已经知道应该调用哪个方法；
（3）虚拟机调用方法。
动态绑定有一个非常重要的特征：无需对现存的代码进行修改，就可以对程序进行扩展。
假设现在增加了一个新类Excutive，并且e有可能引用这个类的对象，我们不需要对包含调用e.getSalary()的代码进行重新编译。如果e恰好引用一个Excutive类的对象，就会自动调用Excutive.getSalary()方法。
5.1.4 阻止继承 final类和方法
有时候，可能希望组织人们利用某个类定义子类，不允许扩张的类称为final类，如果在定义类的时候使用了final修饰符就表示这个类是final类。
将方法或类声明为final的主要目的是：确保它们不会在子类中改变语义。例如，Calender类中的getTime和setTime方法都声明为final。这表明Calender类的设计者负责实现Date类与日历状态之间的转换，而不允许子类处理这些问题。
