2021-10-11 21:57:36

trans/java9-jshell/00.md

-# 序言
+# 零、序言
 
 Java 无疑是本世纪最流行的编程语言之一。然而，每当我们必须快速探索新的算法或新的应用程序域时，Java 并没有为我们提供执行代码片段和打印结果的简单方法。由于这一限制，许多开发人员开始使用其他提供 REPL（Read-Evaluate-Print-Loop）实用程序的编程语言，如 Scala 和 Python。然而，很多时候，在探索阶段结束并且需求和算法明确之后，有必要回到 Java。
 
@@ -24,17 +24,17 @@ Java 是一种多范式编程语言，OOP 是其最重要的范式之一。如
 
 [第五章](05.html#1HIT81-bc1530b4c4784270ae8a31a7038f8341 "Chapter 5. Mutable and Immutable Classes")*可变类和不可变类*介绍了变异对象和非变异对象的区别。首先，我们将创建一个可变类，然后我们将构建该类的不可变版本。在编写并发代码时，我们将学习非变异对象的优点。
 
-[第 6 章](06.html#1R42S2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 6. Inheritance, Abstraction, Extension, and Specialization")*继承、抽象、扩展和专门化*讨论了如何利用简单继承来专门化或扩展基类。我们将自上而下设计许多类，并使用链式构造函数。我们将使用 UML 图来设计从另一个类继承的类。我们将在交互式 JShell 中编码这些类。我们将重写和重载方法。我们将运行代码以了解我们编写的所有东西是如何工作的。
+[第 6 章](06.html#1R42S2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 6. Inheritance, Abstraction, Extension, and Specialization")*继承、抽象、扩展和特化*讨论了如何利用简单继承来特化或扩展基类。我们将自上而下设计许多类，并使用链式构造函数。我们将使用 UML 图来设计从另一个类继承的类。我们将在交互式 JShell 中编码这些类。我们将重写和重载方法。我们将运行代码以了解我们编写的所有东西是如何工作的。
 
 [第 7 章](07.html#21PMQ2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 7. Members Inheritance and Polymorphism")、*成员继承和多态性*教您如何控制子类是否可以覆盖成员。我们将利用最令人兴奋的面向对象特性之一：多态性。我们将利用 JShell 轻松理解类型转换。我们将声明使用类实例执行操作的方法。
 
-[第 8 章](08.html#28FAO2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 8. Contract Programming with Interfaces")*合同编程与接口*介绍了接口如何与 Java 9 中的类结合工作。在 Java9 中实现多重继承的唯一方法是使用接口。我们将学习多个蓝图的声明和组合以生成单个实例。我们将声明具有不同类型需求的接口。然后，我们将声明许多实现所创建接口的类。我们将结合接口和类，以利用 Java9 中的多重继承。我们将结合接口继承和类继承。
+[第 8 章](08.html#28FAO2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 8. Contract Programming with Interfaces")*契约式编程与接口*介绍了接口如何与 Java 9 中的类结合工作。在 Java9 中实现多重继承的唯一方法是使用接口。我们将学习多个蓝图的声明和组合以生成单个实例。我们将声明具有不同类型需求的接口。然后，我们将声明许多实现所创建接口的类。我们将结合接口和类，以利用 Java9 中的多重继承。我们将结合接口继承和类继承。
 
 [第 9 章](09.html#2F4UM2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 9. Advanced Contract Programming with Interfaces")*带接口的高级合约编程*深入探讨了带接口的合约编程。我们将使用接收接口作为参数的方法。我们将了解向下转换如何处理接口和类，并将接口类型的实例视为不同的子类。JShell 将使我们能够轻松理解类型转换和向下转换的复杂性。我们将处理更复杂的场景，其中我们将结合类继承和接口继承。
 
 [第 10 章](10.html#2KS221-bc1530b4c4784270ae8a31a7038f8341 "Chapter 10. Maximization of Code Reuse with Generics")*泛型代码重用的最大化*介绍了如何使用参数多态性。我们将学习如何通过编写能够处理不同类型对象的代码来最大化代码重用，这些对象是实现特定接口或类层次结构包含特定超类的类的实例。我们将使用接口和泛型。我们将创建一个使用受约束泛型类型的类。由于泛型，我们将对多种类型使用泛型类。
 
-[第 11 章](11.html#2TEN41-bc1530b4c4784270ae8a31a7038f8341 "Chapter 11. Advanced Generics")*高级仿制药*深入研究参数多态性。我们将声明一个与两个受约束泛型类型一起工作的类。我们将在 JShell 中使用带有两个泛型类型参数的泛型类。我们将利用 Java9 中的泛型来泛化现有类。
+[第 11 章](11.html#2TEN41-bc1530b4c4784270ae8a31a7038f8341 "Chapter 11. Advanced Generics")*高级多态*深入研究参数多态性。我们将声明一个与两个受约束泛型类型一起工作的类。我们将在 JShell 中使用带有两个泛型类型参数的泛型类。我们将利用 Java9 中的泛型来泛化现有类。
 
 [第 12 章](12.html#335QG2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 12. Object-Oriented, Functional Programming, and Lambda Expressions")、*面向对象、函数式编程和 Lambda 表达式*讨论了函数是 Java 9 中的一级公民。我们将在类中使用函数接口。我们将使用 Java9 中包含的许多函数式编程特性，并将它们与我们在前几章中学习的关于面向对象编程的内容结合起来。这样，我们将能够充分利用这两个世界。我们将分析许多算法的命令式编程方法和函数式编程方法之间的差异。我们将利用 lambda 表达式并将映射操作与 reduce 结合起来。
 

trans/java9-jshell/01.md

-# 第 1 章 JShell–Java 9 的读取-计算-打印循环
+# 一、JShell——Java 9 的读取-求值-打印循环
 
 在本章中，我们将开始使用 Java9 进行面向对象编程的旅程。您将学习如何启动和使用 Java9 引入的新实用程序：JShell，它允许我们轻松运行 Java9 代码片段并打印其结果。此实用程序将使您轻松学习面向对象编程。我们将做以下工作：
 

trans/java9-jshell/02.md

-# 第 2 章。通过 JShell 将现实世界的对象转换为 UML 图和 Java 9
+# 二、通过 Java 9 JShell 将现实世界的对象转换为 UML 图
 
 在本章中，我们将学习如何从现实生活中识别对象。我们将理解，使用对象可以使编写更易于理解和重用的代码变得更简单。我们将学习如何识别真实世界的元素，并将它们转换为 Java9 支持的面向对象范例的不同组件。我们将：
 
@@ -504,6 +504,6 @@ Java9 使用一个点（`.`）来允许我们执行实例的方法。假设我
 
 在本章中，您学习了如何识别真实世界的元素，并将它们转换为 Java 9 支持的面向对象范例的不同组件：类、字段、方法和实例。您知道这些类表示生成对象（也称为实例）的蓝图或模板。
 
-我们设计了几个类，其中包含表示现实对象蓝图的字段和方法，特别是 2D 形状。然后，我们利用抽象和专门化不同类的能力改进了初始设计。在添加超类和子类时，我们生成了初始 UML 图的许多版本。我们了解应用领域，随着知识的增长，我们对原始设计进行了更改，我们意识到我们能够概括行为。
+我们设计了几个类，其中包含表示现实对象蓝图的字段和方法，特别是 2D 形状。然后，我们利用抽象和特化不同类的能力改进了初始设计。在添加超类和子类时，我们生成了初始 UML 图的许多版本。我们了解应用领域，随着知识的增长，我们对原始设计进行了更改，我们意识到我们能够概括行为。
 
 现在您已经学习了面向对象范例的一些基础知识，我们准备开始使用 JShell 在 Java9 中创建类和实例，这是我们将在下一章中讨论的内容。是时候开始面向对象的编码了！
\ No newline at end of file

trans/java9-jshell/03.md

-# 第三章类与实例
+# 三、类与实例
 
 在本章中，我们将开始使用示例，介绍如何在 Java9 中编写类并自定义实例的初始化。我们将了解类如何作为蓝图来生成实例，并深入研究垃圾收集机制。我们将：
 

trans/java9-jshell/04.md

-# 第四章数据封装
+# 四、数据封装
 
 在本章中，我们将学习 Java 9 中类的不同成员，以及它们如何反映在类生成的实例成员中。我们将使用实例字段、类字段、setter、getter、实例方法和类方法。我们将：
 

trans/java9-jshell/05.md

-# 第五章可变类和不可变类
+# 五、可变类和不可变类
 
 在本章中，我们将学习可变类和不可变类。在构建面向对象的代码时，我们将了解它们的差异以及它们的优缺点。我们将：
 
@@ -523,4 +523,4 @@ System.out.printf("%d\n", meowth3.visibilityLevel);
 
 然后，我们利用 JShell 轻松地处理这些类的变异和非变异实例，并分析了更改对象状态和在需要更改其状态时返回新对象之间的区别。我们分析了可变类和不可变类的优缺点，并理解了为什么后者在处理并发代码时很有用。
 
-现在，您已经了解了可变类和不可变类，您已经准备好使用继承、抽象、扩展和专门化，这是我们将在下一章中讨论的主题。
\ No newline at end of file
+现在，您已经了解了可变类和不可变类，您已经准备好使用继承、抽象、扩展和特化，这是我们将在下一章中讨论的主题。
\ No newline at end of file

trans/java9-jshell/06.md

-# 第 6 章继承、抽象、扩展和专门化
+# 六、继承、抽象、扩展和特化
 
 在本章中，我们将学习 Java 9 中面向对象编程最重要的支柱之一：继承。我们将举例说明如何创建类层次结构、重写和重载方法，以及如何使用超类中定义的构造函数。我们将：
 
-*   创建类层次结构以抽象和专门化行为
+*   创建类层次结构以抽象和特化行为
 *   理解继承
 *   创建一个抽象基类
 *   声明从另一个类继承的类
@@ -10,7 +10,7 @@
 *   重写实例方法
 *   重载实例方法
 
-# 创建类层次结构以抽象和专门化行为
+# 创建类层次结构以抽象和特化行为
 
 在前面的章节中，我们已经在 Java9 中创建了类来生成现实对象的蓝图。我们声明了类，然后在 JShell 中创建了这些类的实例。现在是时候利用 Java9 中包含的许多面向对象编程的最高级特性，开始设计类的层次结构，而不是使用孤立的类。首先，我们将根据需求设计我们需要的所有类，然后我们将使用 Java9 中可用的特性来编码所设计的类。
 
@@ -36,7 +36,7 @@
 *   `VirtualBird`：这个类概括了所有的鸟类。鸟类不同于哺乳动物、昆虫、两栖动物和爬行动物。我们已经知道，我们还必须为爬行动物建模。Cockatiel 是一种鸟，因此，我们将创建一个与`VirtualMammal`级别相同的`VirtualBird`类。
 *   `VirtualDomesticMammal`：该类扩展了`VirtualMammal`类。让我们做一些研究，我们会发现老虎（Panthera tigris）是猫科动物中最大、最重的现存物种。老虎是猫，但它与缅因州的浣熊完全不同，后者是一种小型家猫。最初的需求规定我们同时处理虚拟家养动物和虚拟野生动物，因此我们将创建一个类来概括所有虚拟家养哺乳动物。未来，我们将有一个`VirtualWildMammal`亚类，它将概括所有虚拟野生哺乳动物。
 *   `VirtualDomesticBird`：该类扩展了`VirtualBird`类。让我们做一些研究，我们会发现鸵鸟是现存最大的鸟类。鸵鸟是一种鸟，但它与凤尾鹦鹉完全不同，凤尾鹦鹉是一种小型家鸟。我们将与虚拟家禽和虚拟野生鸟类一起工作，因此我们将创建一个类，概括所有虚拟家禽。在未来，我们将有一个`VirtualWildBird`类，它将概括所有虚拟野生鸟类。
-*   `VirtualHorse`：该类扩展了`VirtualDomesticMammal`类。我们可以继续用额外的子类专门化`VirtualDomesticMammal`类，直到我们达到`VirtualHorse`类。例如，我们可以创建一个`VirtualHerbivoreDomesticMammal`子类，然后使`VirtualHorse`类从中继承。但是，我们必须开发的 Web 服务不需要任何介于`VirtualDomesticMammal`和`VirtualHorse`之间的中间类。`VirtualHorse`类概括了我们应用程序中虚拟马所需的字段和方法。`VirtualHorse`类的不同子类将代表虚拟马品种的不同家族。
+*   `VirtualHorse`：该类扩展了`VirtualDomesticMammal`类。我们可以继续用额外的子类特化`VirtualDomesticMammal`类，直到我们达到`VirtualHorse`类。例如，我们可以创建一个`VirtualHerbivoreDomesticMammal`子类，然后使`VirtualHorse`类从中继承。但是，我们必须开发的 Web 服务不需要任何介于`VirtualDomesticMammal`和`VirtualHorse`之间的中间类。`VirtualHorse`类概括了我们应用程序中虚拟马所需的字段和方法。`VirtualHorse`类的不同子类将代表虚拟马品种的不同家族。
 *   `VirtualDomesticRabbit`：该类扩展了`VirtualDomesticMammal`类。`VirtualDomesticRabbit`类概括了我们应用程序中虚拟家养兔子所需的所有字段和方法。
 *   `VirtualDomesticCat`：该类扩展了`VirtualDomesticMammal`类。`VirtualDomesticCat`类概括了我们应用程序中虚拟家猫所需的所有字段和方法。
 *   `AmericanQuarterHorse`：该类扩展了`VirtualHorse`类。`AmericanQuarterHorse`类概括了属于美国四分之一马品种的虚拟马所需的所有字段和方法。
@@ -528,8 +528,8 @@ public void neigh(int times,
 
 # 总结
 
-在本章中，您了解了抽象类和具体类之间的区别。我们学习了如何利用简单继承来专门化基本抽象类。我们使用链式构造函数、不可变字段、可变字段和实例方法从上到下设计了许多类。
+在本章中，您了解了抽象类和具体类之间的区别。我们学习了如何利用简单继承来特化基本抽象类。我们使用链式构造函数、不可变字段、可变字段和实例方法从上到下设计了许多类。
 
 然后，我们利用 Java9 提供的不同特性，在 JShell 中编码了许多此类。我们重载构造函数、重写和重载实例方法，并利用一个特殊的注释来生成重写方法。
 
-现在您已经了解了继承、抽象、扩展和专门化，我们已经准备好完成其他类的编码，并了解如何使用类型转换和多态性，这是我们将在下一章中讨论的主题。**
\ No newline at end of file
+现在您已经了解了继承、抽象、扩展和特化，我们已经准备好完成其他类的编码，并了解如何使用类型转换和多态性，这是我们将在下一章中讨论的主题。**
\ No newline at end of file

trans/java9-jshell/07.md

-# 第七章成员遗传与多态性
+# 七、成员继承与多态性
 
 在本章中，我们将学习 Java9 中面向对象编程最令人兴奋的特性之一：多态性。我们将编写许多类的代码，然后在 JShell 中使用它们的实例，以了解对象如何具有多种不同的形式。我们将：
 
@@ -854,4 +854,4 @@ bunny.isYoungerThan(garfield);
 
 我们使用了许多子类的实例，我们了解到对象可以有多种形式。我们在 JShell 中使用了许多实例及其方法，以了解我们编写的类和方法是如何执行的。我们使用的方法对具有公共超类的不同类的实例执行操作。
 
-现在，您已经了解了成员继承和多态性，我们已经准备好使用 Java 9 中接口的契约编程，这是我们将在下一章中讨论的主题。
\ No newline at end of file
+现在，您已经了解了成员继承和多态性，我们已经准备好使用 Java 9 中接口的契约式编程，这是我们将在下一章中讨论的主题。
\ No newline at end of file

trans/java9-jshell/08.md

-# 第 8 章带接口的合同编程
+# 八、使用接口的契约式编程
 
-在本章中，我们将处理复杂的场景，其中必须使用属于多个蓝图的实例。我们将利用这些接口进行合同编程。我们将：
+在本章中，我们将处理复杂的场景，其中必须使用属于多个蓝图的实例。我们将利用这些接口进行契约式编程。我们将：
 
 *   了解 Java9 中的接口
 *   了解接口如何与类结合工作
@@ -796,4 +796,4 @@ fightableWonderCat1 instanceof Fightable
 
 我们将类继承与接口的实现相结合。我们意识到单个类可以实现多个接口。我们在 JShell 中执行代码，以了解单个实例属于类类型和接口类型。
 
-现在您已经了解了接口和契约编程的基础知识，我们已经准备好使用高级契约编程场景，这是我们将在下一章中讨论的主题。
\ No newline at end of file
+现在您已经了解了接口和契约式编程的基础知识，我们已经准备好使用高级契约式编程场景，这是我们将在下一章中讨论的主题。
\ No newline at end of file

trans/java9-jshell/09.md

-# 第 9 章带接口的高级合同编程
+# 九、使用接口的高级契约式编程
 
-在本章中，我们将深入探讨带有接口的契约编程。我们将更好地理解接口如何作为类型工作。我们将：
+在本章中，我们将深入探讨带有接口的契约式编程。我们将更好地理解接口如何作为类型工作。我们将：
 
 *   使用接收接口作为参数的方法
 *   带有接口和类的 Downcast
@@ -249,7 +249,7 @@ wait(                    x                  y
 
 # 将接口类型的实例视为不同的子类
 
-在[第 7 章](07.html#21PMQ2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 7. Members Inheritance and Polymorphism")*成员遗传与多态性*中，我们研究了多态性。下一个示例并不代表最佳实践，因为多态性是使其工作的方法。然而，我们将编写一些不代表最佳实践的代码，只是为了进一步了解类型转换。
+在[第 7 章](07.html#21PMQ2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 7. Members Inheritance and Polymorphism")*成员继承与多态性*中，我们研究了多态性。下一个示例并不代表最佳实践，因为多态性是使其工作的方法。然而，我们将编写一些不代表最佳实践的代码，只是为了进一步了解类型转换。
 
 下面几行在 JShell 中创建了一个名为`doSomethingWithWonderCat`的方法。我们将使用此方法来理解如何将使用接口类型接收的实例视为不同的子类。样本的代码文件包含在`java_9_oop_chapter_09_01`文件夹中的`example09_02.java`文件中。
 

trans/java9-jshell/10.md

-# 第 10 章。使用泛型实现代码重用的最大化
+# 十、使用泛型实现代码重用的最大化
 
 在本章中，我们将学习参数多态性，以及 Java9 如何通过编写泛型代码来实现这个面向对象的概念。我们将开始创建使用一个受约束泛型类型的类。我们将：
 
@@ -18,7 +18,7 @@
 
 我们想描述一下启动、欢迎成员、组织聚会以及向不同成员告别的程序。然后，我们想用一群天鹅中的天鹅来复制这些程序。因此，我们希望对一群狮子和一群天鹅重复使用我们的程序。将来，我们将需要对其他野生和家养动物，如狐狸、短吻鳄、猫、老虎和狗的聚会使用相同的程序。显然，我们不想成为一群鳄鱼的入侵者。我们也不想参加老虎党。
 
-在前面的章节[第 8 章](08.html#28FAO2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 8. Contract Programming with Interfaces")、*带接口的合同编程*、[第 9 章](09.html#2F4UM2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 9. Advanced Contract Programming with Interfaces")、*带接口的高级合同编程*中，我们学习了使用 Java 9 处理接口。我们可以声明一个接口来指定一个动物的需求，该动物可以参与一个聚会，然后利用 Java 9 的特性编写通用代码，与实现该接口的任何类一起工作。
+在前面的章节[第 8 章](08.html#28FAO2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 8. Contract Programming with Interfaces")、*带接口的契约式编程*、[第 9 章](09.html#2F4UM2-bc1530b4c4784270ae8a31a7038f8341 "Chapter 9. Advanced Contract Programming with Interfaces")、*带接口的高级契约式编程*中，我们学习了使用 Java 9 处理接口。我们可以声明一个接口来指定一个动物的需求，该动物可以参与一个聚会，然后利用 Java 9 的特性编写通用代码，与实现该接口的任何类一起工作。
 
 ### 提示
 
@@ -40,7 +40,7 @@
 
 # 声明要用作类型约束的接口
 
-首先，我们将创建一个`Sociable`接口，指定一个类型必须满足的要求，才能被视为一方的潜在成员，即我们应用领域中的社交动物。然后，我们将创建一个实现该接口的`SociableAnimal`抽象基类，然后将该类专门化为三个具体的子类：`SocialLion`、`SocialParrot`和`SocialSwan`。然后，我们将创建一个`Party`类，该类将能够处理通过泛型实现`Sociable`接口的任何类的实例。我们将创建两个表示特定异常的新类。我们将与一群善于交际的狮子、一只善于交际的鹦鹉和另一只善于交际的天鹅合作。
+首先，我们将创建一个`Sociable`接口，指定一个类型必须满足的要求，才能被视为一方的潜在成员，即我们应用领域中的社交动物。然后，我们将创建一个实现该接口的`SociableAnimal`抽象基类，然后将该类特化为三个具体的子类：`SocialLion`、`SocialParrot`和`SocialSwan`。然后，我们将创建一个`Party`类，该类将能够处理通过泛型实现`Sociable`接口的任何类的实例。我们将创建两个表示特定异常的新类。我们将与一群善于交际的狮子、一只善于交际的鹦鹉和另一只善于交际的天鹅合作。
 
 下面的 UML 图显示了接口、实现它的抽象类以及我们将创建的具体子类，包括所有字段和方法：
 
@@ -790,7 +790,7 @@ Nicholas sings It will be our swan song OO-OO-OO WHO-HO WHO-HO WHO-WHO WHO-WHO
 4.  Java 9 允许我们通过以下方式使用参数多态性：
     1.  鸭子打字。
     2.  兔子打字。
-    3.  仿制药。
+    3.  多态。
 5.  以下哪个代码段声明了一个类，其泛型类型约束指定`T`必须同时实现`Sociable`和`Convertible`接口：
     1.  `public class Game<T extends Sociable & Convertible>`
     2.  `public class Game<T: where T is Sociable & Convertible>`

trans/java9-jshell/11.md

-# 第 11 章高级仿制药
+# 十一、高级多态
 
 在本章中，我们将深入探讨参数多态性，以及 Java9 如何允许我们使用使用两种受约束泛型类型的类编写泛型代码。我们将：
 

trans/java9-jshell/12.md

-# 第 12 章面向对象、函数式编程和 Lambda 表达式
+# 十二、面向对象、函数式编程和 Lambda 表达式
 
 在本章中，我们将讨论函数式编程以及 Java9 如何实现许多函数式编程概念。我们将用许多例子来说明如何将函数式编程与面向对象编程相结合。我们将：
 

trans/java9-jshell/13.md

-# 第 13 章 Java 9 中的模块化
+# 十三、Java 9 中的模块化
 
 在本章中，我们将利用 Java9 中添加的一个新特性，使我们能够模块化源代码并轻松管理依赖关系。我们将：
 
@@ -10,7 +10,7 @@
 
 # 重构现有代码以利用面向对象编程
 
-如果我们从头开始编写面向对象的代码，我们就可以充分利用我们在前几章学到的一切以及 Java9 中包含的所有功能。随着需求的发展，我们必须对接口和类进行更改，以进一步概括或专门化它们，编辑它们，并创建新的接口和类。我们以面向对象的方法开始我们的项目，这一事实将使我们很容易对代码进行必要的调整。
+如果我们从头开始编写面向对象的代码，我们就可以充分利用我们在前几章学到的一切以及 Java9 中包含的所有功能。随着需求的发展，我们必须对接口和类进行更改，以进一步概括或特化它们，编辑它们，并创建新的接口和类。我们以面向对象的方法开始我们的项目，这一事实将使我们很容易对代码进行必要的调整。
 
 有时候，我们非常幸运，一开始我们就有机会遵循最佳实践。然而，很多时候我们并没有这么幸运，我们不得不从事那些没有遵循最佳实践的项目。在这些情况下，我们可以使用我们最喜欢的 IDE 和其他辅助工具提供的功能重构现有代码，并生成面向对象的代码，从而促进代码重用并减少维护方面的麻烦，而不是遵循生成容易出错、重复且难以维护的代码的同样的错误做法。
 

trans/java9-jshell/14.md

-# 附录 A.练习答案
+# 十四、练习答案
 
-# 第 1 章，JShell–Java 9 的读取-计算-打印循环
+# 第 1 章，JShell–Java 9 的读取-求值-打印循环
 
 <colgroup class="calibre15"><col class="calibre16"> <col class="calibre16"></colgroup> 
 | 
@@ -99,7 +99,7 @@
 | 4. | 1. |
 | 5. | 2. |
 
-# 第 6 章，继承、抽象、扩展和专门化
+# 第 6 章，继承、抽象、扩展和特化
 
 <colgroup class="calibre15"><col class="calibre16"> <col class="calibre16"></colgroup> 
 | 
@@ -118,7 +118,7 @@
 | 4. | 3. |
 | 5. | 3. |
 
-# 第七章，成员遗传与多态性
+# 第七章，成员继承与多态性
 
 <colgroup class="calibre15"><col class="calibre16"> <col class="calibre16"></colgroup> 
 | 
@@ -137,7 +137,7 @@
 | 4. | 1. |
 | 5. | 2. |
 
-# 第 8 章，带接口的合同编程
+# 第 8 章，带接口的契约式编程
 
 <colgroup class="calibre15"><col class="calibre16"> <col class="calibre16"></colgroup> 
 | 
@@ -156,7 +156,7 @@
 | 4. | 2. |
 | 5. | 2. |
 
-# 第 9 章，带接口的高级合同编程
+# 第 9 章，带接口的高级契约式编程
 
 <colgroup class="calibre15"><col class="calibre16"> <col class="calibre16"></colgroup> 
 | 
@@ -194,7 +194,7 @@
 | 4. | 3. |
 | 5. | 1. |
 
-# 第 11 章，高级仿制药
+# 第 11 章，高级多态
 
 <colgroup class="calibre15"><col class="calibre16"> <col class="calibre16"></colgroup> 
 |