《Java核心技术卷一》第五章

public class Manager extends Employee
{
    added methods and fields
}

在Java中，所有的继承都是公共继承。

关键字extends指示正在构造的新类派生于一个已存在的类。

这个已存在的类称为超类、基类或父类；新类称为子类或派生类。

子类比超类拥有的功能更多。所有员工组成的集合包含所有经理组成的集合，员工集合是经理集合的超集，经理集合是员工集合的子集。

声明为私有的类成员不会被这个类的子类继承。（私有字段不会继承，因为子类不能直接访问这些私有字段，子类拥有这些字段）

记录，就是状态完全由构造器参数定义的类，不能扩展记录，而且记录也不能扩展其他类。

关键字 super 指示编译器调用超类方法

super(name, salary,...); “调用超类中带有name，salary等参数的构造器的简写形式”

由于子类的构造器不能访问超类的私有字段，所以必须通过一个构造器来初始化这些私有字段，可以利用特殊的super语法调用这个构造器，使用super调用构造器的语句必须是子类构造器的第一条语句。

如果构造子类对象时没有显式的调用超类的构造器，那么超类必须有一个无参数构造器，这个构造器要在子类构造之前调用。

this 的两个含义：一是指示隐式参数的引用；二是调用该类的其他构造器

super 的两个含义：一是调用超类的方法；二是调用超类的构造器

总结：核心逻辑链

创建子类对象 → 需初始化父类 + 子类 → 子类无法直接初始化父类私有字段 → 必须通过“调用父类构造器”完成父类初始化 → super(参数列表) 是调用父类构造器的语法 → 该语句必须是子类构造器第一条语句 → 若子类没显式调用，编译器自动插 super() → 要求父类必须有无参构造器。

一个对象变量可以指示多种实际类型，这一点称为多态，在运行时能够自动地选择适当的方法，这称为动态绑定。

继承并不仅限于一个层次。

由一个公共超类派生出来的所有类的集合称为继承层次结构，在继承层次结构中，从某个特定的类到其祖先的路径称为该类的继承链。

Java不支持多重继承。（多重继承允许一个类同时继承多个父类的属性和方法）

有一个简单的规则可以用来判断是否应该将数据设计为继承关系，这就是“is－a”规则，它指出子类的每个对象也是超类的对象。

“is－a”规则的另一种表述是替换原则。它指出程序中需要超类对象的任何地方都可以使用子类对象替换。

在java中，对象变量是多态的。一个Employee类型的变量既可以引用一个Employee类型的对象，也可以引用Employee类的任何一个子类的对象。

不能将超类的引用赋给子类变量。

在java中，子类引用数组可以转换成超类引用数组，而不需要使用强制类型转换。（存在风险）

理解方法调用

准确地理解如何在对象上应用方法调用非常重要。下面假设要调用x.f(args)，隐式参数

x声明为类C的一个对象。下面是调用过程的详细描述：

1. 编译器查看对象的声明类型和方法名。需要注意的是：有可能存在多个名字为f（参数类类型不一样）的方法。例如，可能存在方法f(int)和方法f(string)。编译器将会一一访问。接下来，编译器已知所有可能调用的候选方法。

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

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

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

注释：前面曾经说过，方法的名字和参数列表称为方法的签名(signature)。例如，f(int)和f(string)是两个有相同名字、不同签名的方法。如果在子类中定义了一个与超类签名相同的方法，那么子类中的这个方法就会覆盖(override)超类中有相同签名的方法。

返回类型不是签名的一部分。不过在覆盖一个方法时，需要保证返回类型的兼容性。允许子类将覆盖方法的返回类型改为原返回类型的子类型。例如，假设Employee类型有以下方法：

public Employee getBuddy() {...}

经理不会想找底层员作为工作搭档。为了反映这一点，在子类Manager中，可以如：

public Manager getBuddy() {...}//ok to change return type

我们说，这两个getBuddy方法有协变(covariant)的返回类型。

3. 如果是private方法、static方法、final方法（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)，那么编译器将搜索超类的方法表。

现在来详细分析程序清单5-1中调用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)

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

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

Manager:

getName() -> Employee.getName()

getSalary() -> Manager.getSalary()

getHireDay() -> Employee.getHireDay()

setBonus(double) -> Manager.setBonus(double)

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

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

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

警告:在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。具体地，如果不小心遗漏了public修饰符。此时，编译器就会报错，指出你试图提供更严格的访问权限。

不允许扩展的类称为final类。

如果在类定义中使用了final修饰符，就表明这个类是fianl类，final类中的方法自动地称为final方法。可以将类中的某个特定方法声明为fianl，如果这样做，那么所有子类都不能覆盖这个方法。字段也可以声明为final，对于final字段来说，构造对象之后就不允许改变了。不过将一个类声明为final，只有其中的方法自动地成为final，不包括字段。

将方法或类声明为final只有一个原因：确保他们不会在子类中改变语义。

如果一个方法没有被覆盖并且很短，编译器就能够对它进行优化处理，则这个过程称为内联（inlining）。

枚举和记录总是final，它们不允许扩展。

要完成对象引用的强制类型转换，转换语法与数值表达式的强制类型转换类似。用一对圆括号将目标类名括起来，并放置在需要转换的对象引用之前。例如：

var staff = new Employee[3];
staff[0] = new Manager("...");
staff[1] = new Employee(".....");
Manager boss = (Manager) staff[0];
Manager boss = (Manager) staff[1];  //error

进行强制类型转换的唯一原因是：要在暂时忘记对象的实际类型之后使用对象的全部功能。 （编译器只认编译时类型，无法访问子类的特有方法）

instanceof操作符，判断是否能够成功进行强制类型转换。(如果x为null 那么 x instanceof C 不会产生异常，只是返回false。因为null没有引用任何对象，当然也不会引用C类型的对象) 例如：

if (staff[i] instanceof Manager)
{
	boss = (Manager) staff[i];
	...
}

综上所述：

只能在继承层次结构内进行强制类型转换。

在将超类强制转换成子类之前，应该使用instanceof进行检查。

if (staff[i] instanceof Manager)
{
	(Manager) boss = (Manager) staff[i];
	boss.setBouns(5000);
}

在java16中可以简化，可以直接在instanceof测试中声明子类变量：（在instanceof判读的同时直接完成类型转换，并声明一个对应的子类变量）

if (staff[i] instanceof Manager boss)
{
	boss.setBouns(5000);
}

当instanceof模式引入一个变量时，可以立即在同一个表达式中使用这个变量（前提是instanceof结果为true）

声明变量的instanceof形式称为“模式匹配”，这是因为它类似于switch中的类型模式，这是java17的一个“预览”特性。

类似于其他局部变量，instanceof模式定义的局部变量会遮蔽字段。

可以将一个类特性（方法或字段）声明为受保护（protected）

在Java中，受保护字段只能由同一个包中的类访问。

1.仅本类可以访问——private

2.可由外部访问——public

3.本包和所有子类可以访问——protected

4.本包中可以访问——默认，不需要修饰符

Object类：所有类的超类

Java中的每一个类都扩展了Object，如果没有明确地指出超类，那么理所当然Object就是这个类的超类。

可以使用Object类型的变量引用任何类型的对象，当然，Object类型的变量只能用于作为任意值的一个泛型容器。

在Java中，只有基本类型（primitive type）不是对象，例如，数值、字符和布尔类型的值都不是对象，

所有的数组类型（不管是对象数组还是基本类型的数组）都扩展了Object类的类类型

Object类中的equals方法用于检测一个对象是否等于另外一个对象。Object类中实现的equals方法将确定两个对象引用是否相同。（即如果两个对象相同，则这两个对象肯定就相等）不过，经常需要基于状态检测对象的相等性。

return name.equals(name, other.name)
	&& salary == other.salary
	&& hireDay.equals(other.hireDay);

为了防止name或hireDay可能为null的情况，需要使用Objects.equals方法。如果两个参数都为null，Objects.equals(a,b)调用将返回true；如果其中一个参数为null，则返回false；如果两个参数都不为null，则调用a.equals(b)。

return Objects.equals(name, other.name)
	&& salary == other.salary
	&& Objects.equals(hireDay, other.hireDay);

在子类中定义equals方法时，首先调用超类的equals。若检测失败，那么对象就不可能相等。如果超类中的字段都相等，则可以继续比较子类中的实例字段。

注释：记录是一种特殊形式的不可变类，其状态完全由“标准”构造器中设置的字段来定义。记录会自动定义一个比较字段的equals方法。两个记录实例中相应字段值相等时，这两个记录实例就相等。

Java语言规范要求equals方法具有下述性质。

1.自反性：对于任何非null引用x，x.equals(x)应该返回true。

2.对称性：对于任何引用x和y，当且仅当y.equals(x)返回true时，x.equals(y)返回true。

3.传递性：对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)也应该返回true。

4.一致性：如果x和y引用的对象没有发生变化，则反复调用x.equals(y)应该返回同样的结果。

5.对于任意非null引用x，x.equals(null)应该返回false。

下面给出编写完美 equals 方法的技巧：

1. 将显式参数命名为 otherObject，稍后需要将它强制转换成另一个名为 other 的变量。

2. 检测 this 与 otherObject 是否相同：

   if (this == otherObject) return true;

   这条语句只是一个优化。实际上，这种情况很常见，因为检查同一性要比逐个比较字段开销小。

3. 检测 otherObject 是否为 null，如果为 null，则返回 false。这个检测是必要的。

   if (otherObject == null) return false;

4. 比较 this 与 otherObject 的类。如果 equals 的语义可以在子类中改变，就使用 getClass 检测：

if (getClass() != otherObject.getClass()) return false;

ClassName other = (ClassName) otherObject;

如果所有的子类都有相同的相等性语义，则可以使用 instanceof 检测：

if (!(otherObject instanceof ClassName other)) return false;

注意，如果 instanceof 检测成功，它会把 other 设置为 otherObject。不再需要强制类型转换。

5.现在根据相等性概念的要求来比较字段。使用 == 比较基本类型字段，使用 Objects.equals 比较对象字段。如果所有的字段都匹配，就返回 true；否则，返回 false。

return field1 == other.field1

	&& Objects.equals(field2, other.field2)

	&& ... ;

如果在子类中重新定义 equals，就要在其中包含一个 super.equals(other) 调用。

提示：对于数组类型的字段，可以使用静态的Arrays.equals方法检查相应的数组元素是否相等。对于多维数组，可以使用Arrays.deepEquals方法。

可以使用 @Override 标记要覆盖超类方法的那些子类方法，如果犯了错误，没有覆盖方法而是在定义一个新方法，编译器就会报告一个错误。

散列码（hash code）是由对象导出的一个整型值。散列码是没有规律的。如果x和y是两个不同的对象，那么 x.hashCode()与y.hashCode()基本上不会相同。

由于hashCode方法定义在 Object 类中，因此每个对象都有一个默认的散列码，其值由对象的存储地址得出。

字符串的散列码是由内容导出的。

String 类使用以下算法计算散列码：

int hash = 0;
for (int i = 0 ; i< length(); i++)
	hash = 31 * hash + charAt(i);

hashCode方法应该返回一个整数（可以是负数）

equals 与 hashCode 的定义必须相容：如果 x.equals(y) 返回 true，那么 x.hashCode() 就必须返回与 y.hashCode() 相同的值，

如果有数组类型的字段，那么可以使用静态的 Arrays.hashCode 方法计算一个散列码，这个散列码由数组元素的散列码组成。

record 类型会自动提供一个 hashCode 方法，它会由字段值的散列码得出一个散列码。

Object中的 toString 方法，它会返回一个字符串，表示这个对象的值。

绝大多数（非全部）toString 方法都遵循这样的格式：首先是类名，随后是一对方括号括起来的字段值。

public String toString()
{
	return getClass().getName() + "[name=" + name + ", salary=" + salary + ",hireDay= " + hireDay + "]";
}

只要对象与一个字符串通过操作符“+”拼接起来，Java编译器就会自动地调用toStirng 方法来获得这个对象的字符串描述。

提示：可以不写为 x.toString()，而写作 ""+x。这条语句将一个空串与 x的字符串表示（也就是 x.toString()）拼接起来。与 toString不同是，即使 x是基本类型，这条语句也能正常工作。

如果 x是一个任意对象，并调用

System.out.println(x);

println方法就会简单地调用 x.toString()，并打印得到的字符串。

Object类定义了 toString方法，会打印对象的类名和散列码。例如，调用

System.out.println(System.out)

将生成以下输出：

java.io.PrintStream@2f6684

之所以得到这样的结果，是因为 PrintStream类的实现者没有覆盖 toString方法。

警告：令人烦恼的是，数组继承了 Object类的 toString方法，更有甚者，数组类型将采用一种古老的格式打印。例如：

int[] luckyNumbers = { 2, 3, 5, 7, 11, 13 };
String s = "" + luckyNumbers;

会生成字符串 “[I@1a46e30”（前缀 [I表示这是一个整型数组）。补救方法是调用静态方法Arrays.toString。以下代码：

String s = Arrays.toString(luckyNumbers);

将生成字符串"[2,3,5,7,11,13]"。

要想正确地打印多维数组（即数组的数组），则需要调用Arrays.deepToString方法。

toString 方法是一种非常有用的调试工具。在标准类库中，许多类都定义了 toString 方法，以便用户能够获得有关对象状态的有用信息。这在记录日志消息时尤其有用，

System.out.println("Current position = " + position);

提示：强烈建议为你自定义的每一个类添加toString方法。

5.3 泛型数组列表

在一些程序设计语言（如 C 或 C++）中，必须在编译时就确定所有数组的大小。程序员对此十分反感，因为这样做将迫使他们做出一些不情愿的折中。例如，一个部门会有多少员工？肯定不会超过 100 人。一旦出现一个拥有 150 名员工的大型部门呢？另外，你愿意为那些仅有 10 名员工的部门浪费 90 个存储空间吗？

在 Java 中，情况就好多了。它允许在运行时确定数组的大小。

int actualSize = . . .;
var staff = new Employee[actualSize];

当然，这个代码并没有完全解决运行时动态修改数组的问题。一旦确定了数组的大小，就无法再轻松地改变了。在 Java 中，要处理这个常见的情况，可以使用 Java 中的另外一个类，名为 ArrayList。ArrayList 类与数组类似，但在添加或删除元素时，它能够自动地调整容量，而不需要为此额外编写代码。

ArrayList 是一个有类型参数（type parameter）的泛型类（generic class）。为了指定数组列表保存的元素对象的类型，需要用一对尖括号将类名括起来追加到 ArrayList 后面，例如 ArrayList。

5.3.1 声明数组列表

可以如下声明和构造一个保存 Employee 对象的数组列表：

ArrayList<Employee> staff = new ArrayList<Employee>();

在 Java 10 中，最好使用 var 关键字以避免重复写类名：

var staff = new ArrayList<Employee>();

如果没有使用 var 关键字，则可以省略右边的类型参数：

ArrayList<Employee> staff = new ArrayList<>();

这称为 “ 菱形 “ 语法，因为它尖括号 <> 就像是一个菱形。可以结合 new 操作符使用菱形语法。编译器会检查新值要做什么。如果赋值给一个变量，或传递给某个方法，或者从某个方法返回，编译器会检查这个变量、参数或方法的泛型类型，然后将这个类型放在 <> 中。在这个例子中，new ArrayList<>( ) 将赋值给一个类型为 ArrayList 的变量，所以泛型类型为 Employee。

警告： **如果使用 var 声明 ArrayList，就不要使用菱形语法。**以下声明

var elements = new ArrayList<>();

会生成一个 ArrayList