2021-10-12 21:28:57

trans/java-se7-prog-study-guide/00.md

-# 序言
+# 零、序言
 
-无论您是在追求 Java 认证，还是想充实自己的知识并在使用 Java 方面获得更多信心，您都会发现这本书很有用。本书采用不同的方法为认证做好准备。它旨在为您提供考试主题的介绍，并为 Java 的使用和 Java 应用程序的开发提供更多的见解。通过提供更广泛的覆盖范围，它超越了直接的认证重点，提供了更全面的语言覆盖范围。
+无论您是在追求 Java 认证，还是想充实自己的知识并在使用 Java 方面获得更多信心，您都会发现这本书很有用。本书采用不同的方法为认证做好准备。它旨在为您提供考试主题的介绍，并为 Java 的使用和 Java 应用的开发提供更多的见解。通过提供更广泛的覆盖范围，它超越了直接的认证重点，提供了更全面的语言覆盖范围。
 
 对于那些追求 Java 认证的人，本书围绕 Java 的主要方面进行组织，并讨论了 JavaSE7 程序员 I（1Z0-803）考试所涵盖的认证主题。每章都涉及特定的认证主题，尽管有些主题包含在不止一章中。在每章的末尾都有认证问题，这些问题将让你了解考试中可能遇到的问题的性质。本书的目的不是提供一组详尽的问题，而是讨论那些重要的 Java 概念，这些概念将帮助您回答认证问题。
 
-对于那些想提高 Java 知识的人来说，本书提供了一些您以前可能从未见过的 Java 知识。特别是，这些图表将有希望增强和巩固您对 Java 如何工作的理解，特别是那些描述程序堆栈和堆的使用的图。本书中提供了一些示例，这些示例解决了在开发 Java 应用程序时发现的许多常见陷阱。
+对于那些想提高 Java 知识的人来说，本书提供了一些您以前可能从未见过的 Java 知识。特别是，这些图表将有希望增强和巩固您对 Java 如何工作的理解，特别是那些描述程序堆栈和堆的使用的图。本书中提供了一些示例，这些示例解决了在开发 Java 应用时发现的许多常见陷阱。
 
 不管你读这本书的原因是什么，我希望你觉得这本书是有价值的和充实的。
 
 # 这本书涵盖的内容
 
-[第 1 章](01.html "Chapter 1. Getting Started with Java")*Java 入门*概述了一个简单的 Java 应用程序，介绍了 Java 的主要方面。`customer`类的创建，以及 getter 和 setter 方法的使用都进行了说明。还讨论了开发过程、支持的 Java 应用程序类型、Java 中的文档过程以及注释的使用，这些都大大增强了 Java 的表达能力。
+[第 1 章](01.html "Chapter 1. Getting Started with Java")*Java 入门*概述了一个简单的 Java 应用，介绍了 Java 的主要方面。`customer`类的创建，以及 getter 和 setter 方法的使用都进行了说明。还讨论了开发过程、支持的 Java 应用类型、Java 中的文档过程以及注释的使用，这些都大大增强了 Java 的表达能力。
 
 [第 2 章](02.html "Chapter 2. Java Data Types and Their Usage")*Java 数据类型及其用法*介绍了 Java 中可用的原始数据类型及其相应的运算符。图表用于解释程序堆栈和堆如何相互关联，以及它们如何影响变量的作用域和生存期。此外，还说明了`String`和`StringBuilder`类的使用，并解释了类和对象之间的区别。
 
@@ -20,13 +20,13 @@
 
 [第 5 章](05.html "Chapter 5. Looping Constructs")*循环构造*通过 while 和 for 循环等构造在 Java 中演示了迭代的概念。这些都包含在使用它们时可能出现的常见错误中。介绍了 for-each 语句和迭代器的使用，以及无限循环和 break-and-continue 语句的覆盖范围。
 
-[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")*类、构造函数和方法*涉及对象的创建和使用，并使用堆栈/堆来解释该过程。讨论了重要的 Java 初始化序列。详细介绍了构造函数和方法的重载，以及签名、实例/静态类成员和不可变对象的概念。数据封装在本章中进行了说明。
+[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")*类、构造器和方法*涉及对象的创建和使用，并使用堆栈/堆来解释该过程。讨论了重要的 Java 初始化序列。详细介绍了构造器和方法的重载，以及签名、实例/静态类成员和不可变对象的概念。数据封装在本章中进行了说明。
 
-[第 7 章](07.html "Chapter 7. Inheritance and Polymorphism")*遗传和多态性*涵盖了遗传和多态性的关键主题，并加强了对构造器和方法的讨论。使用重写时，签名的使用再次变得重要。`super`关键字的威力与构造函数和方法有关。重新检查范围，并探讨最终类和抽象类的概念。还介绍了常在的`Object`类。
+[第 7 章](07.html "Chapter 7. Inheritance and Polymorphism")*继承和多态性*涵盖了继承和多态性的关键主题，并加强了对构造器和方法的讨论。使用重写时，签名的使用再次变得重要。`super`关键字的威力与构造器和方法有关。重新检查范围，并探讨最终类和抽象类的概念。还介绍了常在的`Object`类。
 
-[第 8 章](08.html "Chapter 8. Handling Exceptions in an Application")*处理应用程序*中的异常，涵盖了异常处理，包括使用新的 try with resource 块和 catch 块中的`|`操作符。提供了几个处理异常处理的指南和示例，以帮助读者避免在使用过程中出现常见错误。
+[第 8 章](08.html "Chapter 8. Handling Exceptions in an Application")*处理应用*中的异常，涵盖了异常处理，包括使用新的 try with resource 块和 catch 块中的`|`操作符。提供了几个处理异常处理的指南和示例，以帮助读者避免在使用过程中出现常见错误。
 
-[第 9 章](09.html "Chapter 9. The Java Application")*Java 应用程序*检查了包在 Java 应用程序中的使用。这包括对包和导入语句（包括静态导入语句）使用的讨论。还讨论了如何使用资源包来支持需要面向国际社会的应用程序，以及如何使用 JDBC 连接和使用数据库。
+[第 9 章](09.html "Chapter 9. The Java Application")*Java 应用*检查了包在 Java 应用中的使用。这包括对包和导入语句（包括静态导入语句）使用的讨论。还讨论了如何使用资源包来支持需要面向国际社会的应用，以及如何使用 JDBC 连接和使用数据库。
 
 # 这本书你需要什么
 

trans/java-se7-prog-study-guide/02.md

-# 第二章 Java 数据类型及其使用
+# 二、Java 数据类型及其使用
 
-在本章中，我们将进一步了解 Java 如何组织和操作数据，特别是原始数据类型和字符串。除此之外，我们还将探讨各种相关概念，如变量的作用域和生存期。虽然字符串在 Java 中不是原始数据类型，但它们是许多应用程序的关键部分，我们将研究 Java 提供了什么。
+在本章中，我们将进一步了解 Java 如何组织和操作数据，特别是原始数据类型和字符串。除此之外，我们还将探讨各种相关概念，如变量的作用域和生存期。虽然字符串在 Java 中不是原始数据类型，但它们是许多应用的关键部分，我们将研究 Java 提供了什么。
 
 在本章中，我们将重点关注：
 
@@ -30,7 +30,7 @@
 
 ## 堆积如山
 
-对堆栈/堆和其他问题的透彻理解对于理解程序如何工作以及开发人员如何使用 Java 等语言完成工作至关重要。这些概念为理解应用程序如何工作提供了一个框架，并且是实现 Java 使用的运行时系统的基础，更不用说现有的几乎所有其他编程语言了。
+对堆栈/堆和其他问题的透彻理解对于理解程序如何工作以及开发人员如何使用 Java 等语言完成工作至关重要。这些概念为理解应用如何工作提供了一个框架，并且是实现 Java 使用的运行时系统的基础，更不用说现有的几乎所有其他编程语言了。
 
 这么说来，堆栈和堆的概念相当简单。**堆栈**是每次调用方法时存储方法参数及其局部变量的区域。**堆**是调用`new`关键字时分配对象的内存区域。方法的参数和局部变量组成一个**激活****记录**，也称为**堆栈****帧**。当调用方法时，激活记录被推送到堆栈上，当方法返回时，激活记录被弹出堆栈。这些变量的临时存在决定了变量的生存期。
 
@@ -42,7 +42,7 @@
 
 理解堆栈和堆的概念很重要，因为：
 
-*   它为理解如何在应用程序中组织数据提供了基础。
+*   它为理解如何在应用中组织数据提供了基础。
 *   它有助于解释变量的作用域和生存期的概念
 *   它有助于解释递归是如何工作的
 
@@ -110,11 +110,11 @@ public class CustomerDriver {
   }
 ```
 
-当`main`方法被执行时，激活记录被推送到程序堆栈上。如下图所示，其激活记录仅由单个`args`参数和`customer`参考变量组成。创建`Customer`类的实例时，会在堆上创建并分配一个对象。本例中反映的堆栈和堆的状态发生在`Customer`构造函数执行之后。`args`参考变量指向一个数组。数组的每个元素都引用一个表示应用程序命令行参数的字符串。在下图所示的示例中，我们假设有两个命令行参数，参数 1 和参数 2：
+当`main`方法被执行时，激活记录被推送到程序堆栈上。如下图所示，其激活记录仅由单个`args`参数和`customer`参考变量组成。创建`Customer`类的实例时，会在堆上创建并分配一个对象。本例中反映的堆栈和堆的状态发生在`Customer`构造器执行之后。`args`参考变量指向一个数组。数组的每个元素都引用一个表示应用命令行参数的字符串。在下图所示的示例中，我们假设有两个命令行参数，参数 1 和参数 2：
 
 ![Stack and heap](img/7324_02_02.jpg)
 
-当执行`setBalance`方法时，其激活记录被推送到程序堆栈上，如下所示。`setBalance`方法有一个参数`balance`，分配给`balance`实例变量。但首先，它被用作`BigDecimal`构造函数的参数。`this`关键字引用当前对象。
+当执行`setBalance`方法时，其激活记录被推送到程序堆栈上，如下所示。`setBalance`方法有一个参数`balance`，分配给`balance`实例变量。但首先，它被用作`BigDecimal`构造器的参数。`this`关键字引用当前对象。
 
 Heap 是动态分配给对象的内存。堆管理器控制内存的组织方式。当不再需要某个对象时，将执行一个垃圾收集例程来释放内存，以便可以重复使用。在处理对象之前，执行对象的`finalize`方法。但是，无法保证该方法会执行，因为程序可能会在不需要运行垃圾收集例程的情况下终止。原来的`BigDecimal`物体最终会被摧毁。
 
@@ -122,7 +122,7 @@ Heap 是动态分配给对象的内存。堆管理器控制内存的组织方式
 
 ### 注
 
-在 C++中，当对象即将被销毁时，将执行析构函数。Java 与此最接近的是`finalize`方法，它将在垃圾收集器处理对象时执行。但是，垃圾收集器可能不会运行，因此，`finalize`方法可能永远不会执行。这种范式的转变导致了我们管理资源方式的重大差异。在[第 8 章](08.html "Chapter 8. Handling Exceptions in an Application")中介绍的*处理应用程序*中的异常的【try with resources】块提供了一种处理这种情况的技术。
+在 C++中，当对象即将被销毁时，将执行析构函数。Java 与此最接近的是`finalize`方法，它将在垃圾收集器处理对象时执行。但是，垃圾收集器可能不会运行，因此，`finalize`方法可能永远不会执行。这种范式的转变导致了我们管理资源方式的重大差异。在[第 8 章](08.html "Chapter 8. Handling Exceptions in an Application")中介绍的*处理应用*中的异常的【try with resources】块提供了一种处理这种情况的技术。
 
 ## 声明一个变量
 
@@ -244,7 +244,7 @@ Java 中定义了八种基本数据类型，如下表所示。在 Java 中，所
 
 在使用`BigDecimal`时，必须注意以下几点：
 
-*   使用带有`String`参数的构造函数，因为它在放置小数点方面做得更好
+*   使用带有`String`参数的构造器，因为它在放置小数点方面做得更好
 *   `BigDecimal`是不变的
 *   `ROUND_HALF_EVEN`舍入模式引入的偏差最小
 
@@ -331,7 +331,7 @@ Java 变量的初始化实际上是一个复杂的过程。Java 支持四种初
 *   实例初始值设定项
 *   建设者
 
-在本章中，我们将研究前两种方法。后两种技术在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中进行了介绍，将整个初始化过程放在一起。
+在本章中，我们将研究前两种方法。后两种技术在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中进行了介绍，将整个初始化过程放在一起。
 
 如果未提供显式值，则在创建对象时使用初始默认值。一般来说，当分配对象的字段时，该字段被初始化为零值，如下表所示：
 
@@ -551,7 +551,7 @@ System.out.println();
 | `3._14_15F` | 不能与小数点相邻 |
 | `987_654_321_L` | 不能与`L`后缀相邻 |
 
-有些应用程序需要操纵值的位。下面的示例将使用掩码对值执行按位 AND 操作。掩码是用于隔离另一个值的一部分的位序列。在本例中，`value`表示一个位序列，我们希望分离其最后四位。二进制文字表示掩码：
+有些应用需要操纵值的位。下面的示例将使用掩码对值执行按位 AND 操作。掩码是用于隔离另一个值的一部分的位序列。在本例中，`value`表示一个位序列，我们希望分离其最后四位。二进制文字表示掩码：
 
 ```java
 value & 0b0000_11111;
@@ -652,7 +652,7 @@ cannot assign a value to final variable PI
 
 ### 注
 
-常数除了始终具有相同的值之外，还提供其他好处。可以更有效地处理和优化常量或对象。这使得使用它们的应用程序更高效、更容易理解。我们可以简单地使用`PI`，而不是在每个需要的地方都使用 3.14159。
+常数除了始终具有相同的值之外，还提供其他好处。可以更有效地处理和优化常量或对象。这使得使用它们的应用更高效、更容易理解。我们可以简单地使用`PI`，而不是在每个需要的地方都使用 3.14159。
 
 ### 最后一个关键词
 
@@ -676,7 +676,7 @@ cannot assign a value to final variable PI
 
 ### 枚举
 
-枚举实际上是`java.lang.Enum`类的子类。在本节中，我们将介绍一个简单枚举的创建。在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中可以找到对该主题更完整的处理。
+枚举实际上是`java.lang.Enum`类的子类。在本节中，我们将介绍一个简单枚举的创建。在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中可以找到对该主题更完整的处理。
 
 下面的示例声明了一个名为`Directions`的枚举。此枚举表示四个基点。
 
@@ -727,7 +727,7 @@ Going East
 
 ### 不可变对象
 
-不可变对象是字段不能修改的对象。在 Java 核心 SDK 中有几个类的对象是不可变的，包括`String`类。也许令人惊讶的是，`final`关键字并没有用于此目的。这些在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中有更详细的讨论。
+不可变对象是字段不能修改的对象。在 Java 核心 SDK 中有几个类的对象是不可变的，包括`String`类。也许令人惊讶的是，`final`关键字并没有用于此目的。这些在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中有更详细的讨论。
 
 ## 实例与静态数据
 
@@ -739,7 +739,7 @@ Going East
 private static float discountPercentage;
 ```
 
-静态方法和字段在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中有更详细的介绍。
+静态方法和字段在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中有更详细的介绍。
 
 ## 范围和寿命
 
@@ -936,7 +936,7 @@ i = (int) d;  // Cast a double to an int
 f = (float) d;  // Cast a double to a float
 ```
 
-在这种情况下，如果不使用 cast 运算符，编译器将发出警告。警告是为了建议你更仔细地看作业。精度损失可能是问题，也可能不是问题，这取决于应用程序中数据的使用情况。如果没有强制转换运算符，则在执行代码时进行隐式强制转换。
+在这种情况下，如果不使用 cast 运算符，编译器将发出警告。警告是为了建议你更仔细地看作业。精度损失可能是问题，也可能不是问题，这取决于应用中数据的使用情况。如果没有强制转换运算符，则在执行代码时进行隐式强制转换。
 
 # 使用字符和字符串
 
@@ -953,7 +953,7 @@ f = (float) d;  // Cast a double to a float
 
 Java 程序员可以使用几个与字符串相关的类。在本节中，我们将研究 Java 中用于处理此类数据的类和技术。
 
-JDK 中用于字符串操作的三个主要类是`String`、`StringBuffer`和`StringBuilder`。在这些类别中，`String`类别是使用最广泛的类别。在 Java5 中引入了`StringBuffer`和`StringBuilder`类，以解决`String`类的效率问题。`String`类是不可变的，需要频繁更改字符串的应用程序将承受创建新的不可变对象的开销。`StringBuffer`和`StringBuilder`类是可变对象，当需要频繁修改字符串时，可以更有效地使用它们。`StringBuffer`与`StringBuilder`的不同之处在于其方法是同步的。
+JDK 中用于字符串操作的三个主要类是`String`、`StringBuffer`和`StringBuilder`。在这些类别中，`String`类别是使用最广泛的类别。在 Java5 中引入了`StringBuffer`和`StringBuilder`类，以解决`String`类的效率问题。`String`类是不可变的，需要频繁更改字符串的应用将承受创建新的不可变对象的开销。`StringBuffer`和`StringBuilder`类是可变对象，当需要频繁修改字符串时，可以更有效地使用它们。`StringBuffer`与`StringBuilder`的不同之处在于其方法是同步的。
 
 就类支持的方法而言，`StringBuffer`和`StringBuilder`的方法是相同的。它们只是在方法是否同步方面有所不同。
 
@@ -976,7 +976,7 @@ JDK 中用于字符串操作的三个主要类是`String`、`StringBuffer`和`St
 | `StringBuffer` | 对 | 对 |
 | `StringBuilder` | 对 | 不 |
 
-处理使用多线程的应用程序时，同步方法非常有用。**线程**是一个独立执行的代码序列。它将与同一应用程序中的其他线程同时运行。并发线程不会造成问题，除非它们共享数据。发生这种情况时，该数据可能会损坏。使用同步方法可以解决此问题，并防止由于线程的交互而损坏数据。
+处理使用多线程的应用时，同步方法非常有用。**线程**是一个独立执行的代码序列。它将与同一应用中的其他线程同时运行。并发线程不会造成问题，除非它们共享数据。发生这种情况时，该数据可能会损坏。使用同步方法可以解决此问题，并防止由于线程的交互而损坏数据。
 
 同步方法的使用包括一些开销。因此，如果字符串没有被多个线程共享，则不需要`StringBuffer`类引入的开销。当不需要同步时，大多数情况下应该使用`StringBuilder`类。
 
@@ -1066,7 +1066,7 @@ s = s.concat(" and unchangeable");
 System.out.println(s);
 ```
 
-下面的代码演示了创建`String`对象的几种技术。第一个构造函数将只生成一个空字符串。除非应用程序中需要位于堆上的空不可变字符串，否则这不是立即值。
+下面的代码演示了创建`String`对象的几种技术。第一个构造器将只生成一个空字符串。除非应用中需要位于堆上的空不可变字符串，否则这不是立即值。
 
 ```java
 String firstString = new String();
@@ -1074,7 +1074,7 @@ String secondString = new String("The second string");
 String thirdString = "The third string";
 ```
 
-此外，还有两个构造函数使用`StringBuffer`和`StringBuilder`类。根据这些对象创建新的`String`对象，如下代码序列所示：
+此外，还有两个构造器使用`StringBuffer`和`StringBuilder`类。根据这些对象创建新的`String`对象，如下代码序列所示：
 
 ```java
 StringBuffer stringBuffer =new StringBuffer("A StringBuffer string");
@@ -1147,7 +1147,7 @@ firstLiteral and firstObject are not the same object
 
 ```
 
-`String`类“`intern`方法可用于插入字符串。对所有常量字符串自动执行插入。在比较内部字符串时，可以使用相等运算符，而不必使用`equals`方法。这可以为字符串密集型应用程序节省时间。很容易忘记插入字符串，因此使用相等运算符时要小心。除此之外，`intern`方法可能是一种昂贵的使用方法。
+`String`类“`intern`方法可用于插入字符串。对所有常量字符串自动执行插入。在比较内部字符串时，可以使用相等运算符，而不必使用`equals`方法。这可以为字符串密集型应用节省时间。很容易忘记插入字符串，因此使用相等运算符时要小心。除此之外，`intern`方法可能是一种昂贵的使用方法。
 
 ### 注
 
@@ -1273,7 +1273,7 @@ log
 
 ```
 
-在字符串中搜索字符或字符序列是许多应用程序的常见要求。`indexOf`和`lastIndex`方法执行此类操作：
+在字符串中搜索字符或字符序列是许多应用的常见要求。`indexOf`和`lastIndex`方法执行此类操作：
 
 ```java
 String location = "Irene";
@@ -1406,7 +1406,7 @@ World Class buffering mechanism!
 
 # 总结
 
-在本章中，我们研究了 Java 如何处理数据。堆栈和堆的使用是重要的编程概念，在解释变量的作用域和生存期等概念方面有很大的帮助。对象和基本数据类型之间的差异随着变量的初始化而引入。初始化过程将在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中详细介绍。Java 中可用的运算符与优先级和关联性规则一起列出。此外，还介绍了字符和字符串数据的操作。
+在本章中，我们研究了 Java 如何处理数据。堆栈和堆的使用是重要的编程概念，在解释变量的作用域和生存期等概念方面有很大的帮助。对象和基本数据类型之间的差异随着变量的初始化而引入。初始化过程将在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中详细介绍。Java 中可用的运算符与优先级和关联性规则一起列出。此外，还介绍了字符和字符串数据的操作。
 
 在下一章中，我们将探讨 Java 中可用的决策构造，以及如何有效地使用它们。这将基于此处提供的数据类型。
 

trans/java-se7-prog-study-guide/03.md

-# 第三章决策结构
+# 三、决策结构
 
-每个应用程序都会做出某种决定。在 Java 中有几种编程结构，我们可以使用它们来做出这些决策。其中包括逻辑表达式、if 语句和 switch 语句。本章的目的是向您介绍这些工具，并说明如何使用它们。
+每个应用都会做出某种决定。在 Java 中有几种编程结构，我们可以使用它们来做出这些决策。其中包括逻辑表达式、if 语句和 switch 语句。本章的目的是向您介绍这些工具，并说明如何使用它们。
 
 我们将首先讨论逻辑表达式，因为它们是决策的核心。逻辑表达式是返回布尔值的表达式。
 
@@ -22,7 +22,7 @@
 
 # 控制流程
 
-在任何应用程序中，程序中的控制流由语句的执行顺序决定。将语句组看作是由决策语句控制执行的块是很方便的。一个块可以被看作是一个单独的语句或一个块语句中包含的几个语句。Java 中的 block 语句是一组用大括号括起来的语句。
+在任何应用中，程序中的控制流由语句的执行顺序决定。将语句组看作是由决策语句控制执行的块是很方便的。一个块可以被看作是一个单独的语句或一个块语句中包含的几个语句。Java 中的 block 语句是一组用大括号括起来的语句。
 
 ## 控制声明–概述
 
@@ -736,7 +736,7 @@ if (limit > 100)
 if (limit > 100) if (stateCode == 45) limit = limit+10; else limit = limit-10;
 ```
 
-本例中的第二个问题是未能使用 block 语句。块语句不仅提供了一种对语句进行分组的方法，而且还提供了一种更清晰地传达应用程序逻辑的方法。此问题可以解决，如下代码所示：
+本例中的第二个问题是未能使用 block 语句。块语句不仅提供了一种对语句进行分组的方法，而且还提供了一种更清晰地传达应用逻辑的方法。此问题可以解决，如下代码所示：
 
 ```java
 if (limit > 100) {
@@ -1048,14 +1048,14 @@ switch (zone) {
 
 *   始终保留一个`else`条款
 *   测试你的假设
-*   抛出异常（参见[第 8 章](08.html "Chapter 8. Handling Exceptions in an Application")、*处理应用程序*中的异常）
+*   抛出异常（参见[第 8 章](08.html "Chapter 8. Handling Exceptions in an Application")、*处理应用*中的异常）
 *   始终使用块语句
 
 当所有其他方法都失败时，请使用调试技术。
 
 ## 浮点数注意事项
 
-浮点数在内部使用 IEEE 754 浮点数算术标准（[表示 http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=4610933](http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=4610933) ）。这些操作通常在软件中执行，因为并非所有平台都为标准提供硬件支持。在软件中执行这些操作将比直接在硬件中执行的操作慢。在软件中执行这些操作的优点是它支持应用程序的可移植性。
+浮点数在内部使用 IEEE 754 浮点数算术标准（[表示 http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=4610933](http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=4610933) ）。这些操作通常在软件中执行，因为并非所有平台都为标准提供硬件支持。在软件中执行这些操作将比直接在硬件中执行的操作慢。在软件中执行这些操作的优点是它支持应用的可移植性。
 
 支持两种浮点类型，`float`和`double`，精度如下表所示。此外，`Integer`和`Float`类是这两种数据类型的包装类。包装类用于封装值，例如整数或浮点数：
 
@@ -1087,7 +1087,7 @@ switch (zone) {
 
 有几个特殊的浮点值，如下表所示。它们的存在使得当错误条件发生时，将有一个表示法可用于识别错误。
 
-这些值的存在使得错误条件（如算术溢出、取负数的平方根和除以 0）可以产生可以在浮点值内表示的结果，而不会引发异常或以其他方式终止应用程序：
+这些值的存在使得错误条件（如算术溢出、取负数的平方根和除以 0）可以产生可以在浮点值内表示的结果，而不会引发异常或以其他方式终止应用：
 
 <colgroup><col style="text-align: left"> <col style="text-align: left"> <col style="text-align: left"></colgroup> 
 | 
@@ -1109,7 +1109,7 @@ switch (zone) {
 | 正无穷大 | 非常大的价值 | 被零除的正数 |
 | 负零 | 负零 | 负数非常接近于零，但不能正常表示 |
 
-如有必要，可以用代码`Float.NaN`和`Double.NaN`表示 NaN。使用 NaN 值执行算术运算将产生 NaN 结果。将 NaN 转换为整数将返回`0`，这可能导致应用程序错误。以下代码序列说明了 NaN 的使用：
+如有必要，可以用代码`Float.NaN`和`Double.NaN`表示 NaN。使用 NaN 值执行算术运算将产生 NaN 结果。将 NaN 转换为整数将返回`0`，这可能导致应用错误。以下代码序列说明了 NaN 的使用：
 
 ```java
 float num1 = 0.0f;
@@ -1269,7 +1269,7 @@ System.out.println(sum);
 
 ### strictfp 关键字
 
-`strictfp`关键字可以应用于类、接口或方法。在 Java 2 之前，所有浮点计算都是按照 IEEE 754 规范执行的。Java2 之后，中间计算不再局限于标准，允许使用某些处理器上可用的额外位来提高精度。由于四舍五入的差异，这可能导致应用程序的可移植性降低。通过使用`strictfp`关键字，所有计算将严格遵守 IEEE 标准。
+`strictfp`关键字可以应用于类、接口或方法。在 Java 2 之前，所有浮点计算都是按照 IEEE 754 规范执行的。Java2 之后，中间计算不再局限于标准，允许使用某些处理器上可用的额外位来提高精度。由于四舍五入的差异，这可能导致应用的可移植性降低。通过使用`strictfp`关键字，所有计算将严格遵守 IEEE 标准。
 
 ## 比较对象
 
@@ -1291,7 +1291,7 @@ System.out.println(sum);
 *   `r2 != r3`
 *   `r1.equals(r2)`
 
-然而，根据对象和对象本身的`equals`方法的实现，对象 1 可能等价于对象 2，也可能不等价于对象 2。在[第 2 章](02.html "Chapter 2. Java Data Types and Their Usage")*Java 数据类型及其用法*中的*字符串比较*一节中详细介绍了字符串的比较。重写`equals`方法在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中进行了讨论。
+然而，根据对象和对象本身的`equals`方法的实现，对象 1 可能等价于对象 2，也可能不等价于对象 2。在[第 2 章](02.html "Chapter 2. Java Data Types and Their Usage")*Java 数据类型及其用法*中的*字符串比较*一节中详细介绍了字符串的比较。重写`equals`方法在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中进行了讨论。
 
 ## 三种基本编码活动
 
@@ -1307,7 +1307,7 @@ System.out.println(sum);
 *   “如何”确定如何编写代码，使用工作时间和工资率计算工资
 *   “何时”涉及代码的放置位置，即工作时间和工资率确定后
 
-虽然这看起来很简单，但许多刚开始编程的程序员在“何时”编程方面会遇到问题。这对于今天基于**图形用户界面**（**GUI**）的应用程序所代表的事件驱动程序尤其如此。
+虽然这看起来很简单，但许多刚开始编程的程序员在“何时”编程方面会遇到问题。这对于今天基于**图形用户界面**（**GUI**）的应用所代表的事件驱动程序尤其如此。
 
 ## goto 声明
 

trans/java-se7-prog-study-guide/04.md

-# 第四章使用数组和集合
+# 四、使用数组和集合
 
 这一章的实质是关于数据结构的。具体来说，它是关于`java.util.Arrays`和`java.util.ArrayList`类的数组。数组是可以使用单个变量名寻址的内存区域。它提供了一种以顺序或随机方式访问数据的有效技术。`Arrays`类提供对数组的支持，`ArrayList`类提供类似数组的行为，但大小不固定。
 
@@ -14,7 +14,7 @@
 
 数组允许使用单个变量名访问多个值。数组的每个元素都是相同类型的。元素类型可以是简单的基本数据类型，也可以是对对象的引用。
 
-一维数组被分配给一个连续的内存区域。这意味着可以有效地访问阵列的元素，因为它们彼此相邻。数组使用整数索引访问数组中的元素。索引范围从 0 到数组长度减 1。我们可以根据应用程序的需要以任何顺序直接访问数组的元素，而不必访问每个元素。
+一维数组被分配给一个连续的内存区域。这意味着可以有效地访问阵列的元素，因为它们彼此相邻。数组使用整数索引访问数组中的元素。索引范围从 0 到数组长度减 1。我们可以根据应用的需要以任何顺序直接访问数组的元素，而不必访问每个元素。
 
 尽管 Java 支持多维数组，但最常用的还是一维数组。阵列可用于多种用途，包括：
 
@@ -357,7 +357,7 @@ grades[1] = new int[2];
 *   传递数组
 *   使用命令行参数
 
-我们将根据情况演示每种技术的变化。[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中介绍了向方法传递可变数量的参数。
+我们将根据情况演示每种技术的变化。[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中介绍了向方法传递可变数量的参数。
 
 ### 遍历数组
 
@@ -809,11 +809,11 @@ Length of arr2: 5
 
 ### 使用命令行参数
 
-当 Java 应用程序执行时，执行的第一个方法是`main`方法。这个方法传递一个参数，一个名为`args`的`String`对象数组。这些字符串对应于命令行上提供的字符串。
+当 Java 应用执行时，执行的第一个方法是`main`方法。这个方法传递一个参数，一个名为`args`的`String`对象数组。这些字符串对应于命令行上提供的字符串。
 
 Java 数组的`length`属性将告诉我们使用了多少个命令行参数。数组的第一个参数将包含第一个命令行参数。第二个将包含第二个命令行参数，依此类推。
 
-以下`CommandLineDemo`应用程序说明了`args`阵列的使用：
+以下`CommandLineDemo`应用说明了`args`阵列的使用：
 
 ```java
 public class CommandLineDemo {
@@ -828,7 +828,7 @@ public class CommandLineDemo {
 }
 ```
 
-考虑使用以下命令行参数调用 AutoT0R 应用程序：
+考虑使用以下命令行参数调用 AutoT0R 应用：
 
 ```java
 java CommandLineDemo /D 1024 /f test.dat
@@ -992,13 +992,13 @@ System.out.println(Arrays.toString(arr3));
 
 ### 创建 ArrayList
 
-`ArrayList`类具有以下三个构造函数：
+`ArrayList`类具有以下三个构造器：
 
-*   默认构造函数
+*   默认构造器
 *   接受`Collection`对象的人
 *   接受初始容量的人
 
-`ArrayList`对象的容量是指列表可以容纳多少元素。当需要添加更多元素且列表已满时，列表的大小将自动增加。使用默认构造函数创建的`ArrayList`的初始容量为`10`。以下示例创建了两个列表，一个容量为`10`，第二个容量为`20`：
+`ArrayList`对象的容量是指列表可以容纳多少元素。当需要添加更多元素且列表已满时，列表的大小将自动增加。使用默认构造器创建的`ArrayList`的初始容量为`10`。以下示例创建了两个列表，一个容量为`10`，第二个容量为`20`：
 
 ```java
 ArrayList list1 = new ArrayList();
@@ -1280,7 +1280,7 @@ public class Library {
 }
 ```
 
-这是数据封装的一个很好的例子。但是，请确保不要无意中公开私有数据。在`getBook`方法中，我们返回了对该书的引用。此参考允许用户修改书籍。如果不允许进行此修改，则可以返回该书的副本，如下所示。这假设`Book`类有一个构造函数，该构造函数根据构造函数的参数制作一本书的新副本：
+这是数据封装的一个很好的例子。但是，请确保不要无意中公开私有数据。在`getBook`方法中，我们返回了对该书的引用。此参考允许用户修改书籍。如果不允许进行此修改，则可以返回该书的副本，如下所示。这假设`Book`类有一个构造器，该构造器根据构造器的参数制作一本书的新副本：
 
 ```java
 public Book getBook (int index) {

trans/java-se7-prog-study-guide/05.md

-# 第五章循环构造
+# 五、循环结构
 
 经常需要一次又一次地重复一系列动作。例如，我们可能希望显示存储在数组中的组织中员工的信息。数组的每个元素都可能包含对`Employee`对象的引用。对对象方法的调用将放置在循环构造中。
 
@@ -114,7 +114,7 @@ for(int i = 0, j = 10; j > 5; i++, j--) {
 }
 ```
 
-注意在`printf`语句中使用了`%n`格式说明符。这指定应生成新行字符。此外，这种新的行分隔符是特定于平台的，使应用程序更具可移植性。
+注意在`printf`语句中使用了`%n`格式说明符。这指定应生成新行字符。此外，这种新的行分隔符是特定于平台的，使应用更具可移植性。
 
 执行时，此代码序列将产生以下输出：
 
@@ -363,7 +363,7 @@ for(int i = 0; i < 5; i++) {
 
 ## 使用 for each 语句和列表
 
-我们将从开始，用`ArrayList`说明 for-each 语句的用法。`ArrayList`类实现了`List`接口，扩展了`Collection`接口。接口的使用和声明在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中有更详细的说明。由于 for-each 语句可以用于实现`Collection`接口的类，因此我们也可以将其用于`ArrayList`类。在下一节中，我们将创建自己的`Iterable`类：
+我们将从开始，用`ArrayList`说明 for-each 语句的用法。`ArrayList`类实现了`List`接口，扩展了`Collection`接口。接口的使用和声明在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中有更详细的说明。由于 for-each 语句可以用于实现`Collection`接口的类，因此我们也可以将其用于`ArrayList`类。在下一节中，我们将创建自己的`Iterable`类：
 
 ```java
 ArrayList<String> list = new ArrayList<String>();
@@ -577,7 +577,7 @@ java.lang.NullPointerException
 
 ### 参数数量可变
 
-for-each 语句在使用可变数量参数的方法中运行良好。在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造函数和方法*中的*变量数量*部分，可以找到使用变量数量的方法的更详细说明。
+for-each 语句在使用可变数量参数的方法中运行良好。在[第 6 章](06.html "Chapter 6. Classes, Constructors, and Methods")、*类、构造器和方法*中的*变量数量*部分，可以找到使用变量数量的方法的更详细说明。
 
 在下面的方法中，我们传递数量可变的整数参数。接下来，我们计算这些整数的累积和并返回总和：
 

trans/java-se7-prog-study-guide/08.md

-# 第 8 章处理应用程序中的异常
+# 八、处理应用中的异常
 
-异常是应用程序或**Java 虚拟机****JVM**在发生某种错误时抛出的对象。Java 提供了一系列预定义的异常，并允许开发人员声明和创建自己的异常类。
+异常是应用或**Java 虚拟机****JVM**在发生某种错误时抛出的对象。Java 提供了一系列预定义的异常，并允许开发人员声明和创建自己的异常类。
 
 虽然有许多方法可以对异常进行分类，但有一种方案将其分为三种类型：
 
@@ -24,7 +24,7 @@
 
 此方法的另一种替代方法是“捕获”错误。大多数现代块结构语言（如 Java）都使用这种方法。这种技术需要更少的编码，更具可读性和鲁棒性。当例程检测到错误时，它“抛出”异常对象。然后将异常对象返回给调用方，调用方随后捕获并处理错误。
 
-出于多种原因，应捕获异常。未能处理异常可能会导致应用程序失败，或最终处于无效状态，输出不正确。保持一个一致的环境总是一个好主意。此外，如果您打开一个资源，如文件，则在完成时应始终关闭该资源，但最琐碎的程序除外。
+出于多种原因，应捕获异常。未能处理异常可能会导致应用失败，或最终处于无效状态，输出不正确。保持一个一致的环境总是一个好主意。此外，如果您打开一个资源，如文件，则在完成时应始终关闭该资源，但最琐碎的程序除外。
 
 Java 中可用的异常处理机制允许您这样做。打开资源时，即使程序中发生异常，也可以将其关闭。为完成此任务，资源在`try`块中打开，在`catch`或`finally`块中关闭。`try`、`catch`和`finally`块构成了 Java 中使用的异常处理机制的核心。
 
@@ -135,7 +135,7 @@ private static void losingStackTrace(){
 
 ```
 
-由于某些 IDE 的性质，应用程序的标准输出和标准错误输出可以交错。例如，执行上述序列可能导致以下输出。您可能没有或可能在输出中看到交错。输出前面的破折号用于帮助查看交错行为：
+由于某些 IDE 的性质，应用的标准输出和标准错误输出可以交错。例如，执行上述序列可能导致以下输出。您可能没有或可能在输出中看到交错。输出前面的破折号用于帮助查看交错行为：
 
 ```java
 java.io.FileNotFoundException: c:\NonExistentFile.txt (The system cannot find the file specified)
@@ -606,10 +606,10 @@ Exception in thread "main" packt.MyException
 
 可以重新抛出并保留堆栈跟踪。为此，我们需要执行以下操作：
 
-1.  添加一个以`Throwable`对象作为参数的构造函数。
+1.  添加一个以`Throwable`对象作为参数的构造器。
 2.  当我们想要保留堆栈跟踪时，请使用此选项。
 
-下面显示了添加到`MyException`类中的此类构造函数：
+下面显示了添加到`MyException`类中的此类构造器：
 
 ```java
 public MyException(Throwable cause) {
@@ -618,7 +618,7 @@ public MyException(Throwable cause) {
 
 ```
 
-在`catch`块中，我们将使用此构造函数，如下所示。
+在`catch`块中，我们将使用此构造器，如下所示。
 
 ```java
 catch (FileNotFoundException e) {
@@ -756,7 +756,7 @@ class Base {
 
 ## 忽略异常
 
-忽略例外情况通常是一种不好的做法。它们被抛出是有原因的，如果你可以做些什么来恢复，那么你应该处理它。否则，您至少可以优雅地终止应用程序。
+忽略例外情况通常是一种不好的做法。它们被抛出是有原因的，如果你可以做些什么来恢复，那么你应该处理它。否则，您至少可以优雅地终止应用。
 
 例如，通常忽略一个`InterruptedException`，如以下代码片段所示：
 
@@ -793,11 +793,11 @@ private static void losingStackTrace(){
 
 当一个方法抛出异常时，该方法的用户可以在该点处理该异常，也可以将异常沿着调用序列传递给另一个方法。诀窍是在适当的级别处理异常。该级别通常是可以处理异常的级别。
 
-例如，如果需要应用程序用户的输入才能成功处理异常，则应使用最适合与用户交互的级别。如果该方法是库的一部分，那么假设应该提示用户可能不合适。当我们试图打开一个文件而该文件不存在时，我们不希望或希望调用的方法提示用户输入其他文件名。相反，我们更倾向于自己动手。在某些情况下，甚至可能没有用户提示，就像许多服务器应用程序一样。
+例如，如果需要应用用户的输入才能成功处理异常，则应使用最适合与用户交互的级别。如果该方法是库的一部分，那么假设应该提示用户可能不合适。当我们试图打开一个文件而该文件不存在时，我们不希望或希望调用的方法提示用户输入其他文件名。相反，我们更倾向于自己动手。在某些情况下，甚至可能没有用户提示，就像许多服务器应用一样。
 
 ## 一个街区抓的太多
 
-当我们向应用程序添加 catch 块时，我们经常试图通过使用基类异常类来捕获它们，从而使用最少数量的 catch 块。下面说明了 catch 块使用`Exception`类捕获多个异常的情况。在这里，我们假设可以抛出多个已检查异常并需要处理：
+当我们向应用添加 catch 块时，我们经常试图通过使用基类异常类来捕获它们，从而使用最少数量的 catch 块。下面说明了 catch 块使用`Exception`类捕获多个异常的情况。在这里，我们假设可以抛出多个已检查异常并需要处理：
 
 ```java
 try {
@@ -832,7 +832,7 @@ catch (Exception1 e4) {
 
 ## 日志记录异常
 
-通常的做法是记录异常，即使它们已成功处理。这在评估应用程序的行为时非常有用。当然，如果我们无法处理异常，需要优雅地终止应用程序，那么错误日志在确定应用程序中出现了什么错误时非常有用。
+通常的做法是记录异常，即使它们已成功处理。这在评估应用的行为时非常有用。当然，如果我们无法处理异常，需要优雅地终止应用，那么错误日志在确定应用中出现了什么错误时非常有用。
 
 ### 注
 
@@ -886,7 +886,7 @@ if(state != null && state.equals("Ready") {
 
 # 总结
 
-程序中适当的异常处理将增强其健壮性和可靠性。`try`、`catch`和`finally`块可用于在应用程序内实现异常处理。在 Java7 中，添加了 try with resources 块，它更容易处理资源的打开和关闭。还可以传播异常以备份调用序列。
+程序中适当的异常处理将增强其健壮性和可靠性。`try`、`catch`和`finally`块可用于在应用内实现异常处理。在 Java7 中，添加了 try with resources 块，它更容易处理资源的打开和关闭。还可以传播异常以备份调用序列。
 
 我们了解到，为了正确处理异常，catch 块的顺序非常重要。此外，`|`操作符可以在 catch 块中使用，以相同的方式处理多个异常。
 

trans/java-se7-prog-study-guide/09.md

-# 第九章 Java 应用
+# 九、Java 应用
 
-在本章中，我们将从包的角度研究 Java 应用程序的结构。将介绍包和导入语句的使用，以及用于包的底层目录结构。
+在本章中，我们将从包的角度研究 Java 应用的结构。将介绍包和导入语句的使用，以及用于包的底层目录结构。
 
 我们还将看到 Java 如何通过使用区域设置和资源包来支持国际化。将介绍 JDBC 的使用，以及如何回收未使用的对象。这通常被称为**垃圾收集**。
 
 # 代码组织
 
-代码的组织是应用程序的重要组成部分。我们甚至可以说，正是这个组织（以及数据组织）决定了应用程序的质量。
+代码的组织是应用的重要组成部分。我们甚至可以说，正是这个组织（以及数据组织）决定了应用的质量。
 
-Java 应用程序是围绕包组织的。包包含类。类包含数据和代码。代码可以在初始值设定项列表或方法中找到。该基本组织如下图所示：
+Java 应用是围绕包组织的。包包含类。类包含数据和代码。代码可以在初始值设定项列表或方法中找到。该基本组织如下图所示：
 
 ![Code organization](img/7324_09_01.jpg)
 
@@ -48,7 +48,7 @@ class Phone {
 }
 ```
 
-Java 源代码文件放在一个文件中，该文件与使用`.java`扩展名的类同名。如果文件中保存了多个类，则只能将一个类声明为公共类，并且文件必须以该公共类命名。`java.lang`包包含许多常用类，并自动包含在每个应用程序中。
+Java 源代码文件放在一个文件中，该文件与使用`.java`扩展名的类同名。如果文件中保存了多个类，则只能将一个类声明为公共类，并且文件必须以该公共类命名。`java.lang`包包含许多常用类，并自动包含在每个应用中。
 
 第二个要求是将类文件移动到适当的包目录。在系统的某个地方必须存在一个反映包名的目录结构。例如，对于包名`employee.benefits`，需要有一个名为`employee`的目录，该目录的子目录名为`benefits`。`employee`包的所有类文件都放在`employee`目录中。`employee.benefits`包的所有类文件都放在`benefits`子目录中。如下图所示，目录和文件位于`C`驱动器的某个地方：
 
@@ -91,7 +91,7 @@ import java.io.BufferReader;
 
 ### 使用通配符
 
-如果需要使用多个类，并且在同一个包中找到它们，则可以使用星号，而不是包含多个导入语句，每个类一个。例如，如果我们需要在应用程序中同时使用`BufferedReader`和`BufferedWriter`类，我们可以使用两个导入语句，如下所示：
+如果需要使用多个类，并且在同一个包中找到它们，则可以使用星号，而不是包含多个导入语句，每个类一个。例如，如果我们需要在应用中同时使用`BufferedReader`和`BufferedWriter`类，我们可以使用两个导入语句，如下所示：
 
 ```java
 import java.io.BufferedReader;
@@ -208,7 +208,7 @@ s1 = null;
 s2 = null;
 ```
 
-下图显示了执行这些语句后应用程序的状态：
+下图显示了执行这些语句后应用的状态：
 
 ![Garbage collection](img/7324_09_05.jpg)
 
@@ -223,13 +223,13 @@ s2 = null;
 
 # 资源包和 Locale 类
 
-`Locale`类是用来代表世界的一部分。与区域设置关联的是一组与诸如控制货币或日期显示方式等活动有关的约定。区域设置的使用有助于应用程序的国际化。开发人员指定区域设置，然后在应用程序的各个部分中使用该区域设置。
+`Locale`类是用来代表世界的一部分。与区域设置关联的是一组与诸如控制货币或日期显示方式等活动有关的约定。区域设置的使用有助于应用的国际化。开发人员指定区域设置，然后在应用的各个部分中使用该区域设置。
 
 除了`Locale`类之外，我们还可以使用资源束。它们提供了一种方法，可以根据除数字和日期以外的数据类型的区域设置自定义外观。它在处理基于区域设置更改的字符串时特别有用。
 
-例如，GUI 应用程序将具有不同的可视组件，在世界不同地区使用时，这些组件的文本应该不同。在西班牙，文本和货币应以西班牙语显示。在中国，应该使用汉字和惯例。使用地区可以简化应用程序适应世界不同地区的过程。
+例如，GUI 应用将具有不同的可视组件，在世界不同地区使用时，这些组件的文本应该不同。在西班牙，文本和货币应以西班牙语显示。在中国，应该使用汉字和惯例。使用地区可以简化应用适应世界不同地区的过程。
 
-在本节中，我们将讨论用于支持应用程序国际化的三种方法：
+在本节中，我们将讨论用于支持应用国际化的三种方法：
 
 *   使用`Locale`类
 *   使用属性资源文件
@@ -469,7 +469,7 @@ public class ListResource extends ListResourceBundle {
 }
 ```
 
-创建的`ArrayList`用于存储各种名称前缀。它是使用`asList`方法创建的，该方法被传递一个可变数量的字符串参数，并将`List`返回给`ArrayList`构造函数。
+创建的`ArrayList`用于存储各种名称前缀。它是使用`asList`方法创建的，该方法被传递一个可变数量的字符串参数，并将`List`返回给`ArrayList`构造器。
 
 下面的代码演示了如何使用`ListResource`。创建一个`ListResource`实例，然后使用字符串键执行`getString`方法。对于`PREFIXES`键，使用`getObject`方法：
 
@@ -633,7 +633,7 @@ JDBC 支持使用其他 SQL 语句，如`update`和`delete`。此外，它还支
 
 # 总结
 
-在本章中，我们重新检查了 Java 应用程序的总体结构。我们检查了`import`和`package`语句的使用，并讨论了包库与其支持的目录/文件基础之间的关系。我们学习了如何在`import`语句中使用星号通配符。此外，我们还看到了静态导入语句的使用。
+在本章中，我们重新检查了 Java 应用的总体结构。我们检查了`import`和`package`语句的使用，并讨论了包库与其支持的目录/文件基础之间的关系。我们学习了如何在`import`语句中使用星号通配符。此外，我们还看到了静态导入语句的使用。
 
 我们讨论了初始值设定项列表的使用以及垃圾收集在 Java 中的工作方式。此过程可在不再需要对象时自动恢复对象。
 

trans/java-se7-prog-study-guide/10.md

-# 附录 A.测试你的知识-答案
+# 十、测试你的知识——答案
 
 # 第 1 章：Java 入门
 
@@ -117,7 +117,7 @@ int arr[] = new int[5];
 | 4. | a、 b、c 和 d | 它们都是等价的。 |
 | 5. | A. | continue 语句跳过`j`的值`3`。 |
 
-# 第六章：类、构造函数和方法
+# 第六章：类、构造器和方法
 
 <colgroup><col style="text-align: left"> <col style="text-align: left"> <col style="text-align: left"></colgroup> 
 | 
@@ -137,12 +137,12 @@ int arr[] = new int[5];
 | 1. | a、 c 和 d | 选项 b 无法正确初始化阵列。 |
 | 2. | C | 不能从静态方法访问实例方法。 |
 | 3. | A. | 重载方法时不考虑返回值。 |
-| 4. | c 和 d | 最后一行是一个与构造函数同名的方法。由于定义了构造函数但没有默认构造函数，因此该类没有默认构造函数。 |
+| 4. | c 和 d | 最后一行是一个与构造器同名的方法。由于定义了构造器但没有默认构造器，因此该类没有默认构造器。 |
 | 5. | a 和 b | 声明类时只能使用`private`和`public`关键字，`private`关键字只能用于内部类。 |
 | 6. | C | 因为类在同一个包中，除了私有方法之外，所有方法都是可见的。 |
 | 7. | D | main 中的`i`变量没有修改，因为它是通过值传递的。当字符串通过引用传递时，局部变量`s`在第三种方法中被修改，而不是在`main`方法中被修改。 |
 
-# 第七章：遗传与多态
+# 第七章：继承与多态
 
 <colgroup><col style="text-align: left"> <col style="text-align: left"> <col style="text-align: left"></colgroup> 
 | 
@@ -163,10 +163,10 @@ int arr[] = new int[5];
 | 2. | a 和 d | 重载只发生在同一个类中。不需要有基类。通用实现的接口也适用于多态行为。 |
 | 3. | D | 其他方法不存在。 |
 | 4. | B | 其他将生成语法错误。 |
-| 5. | C | 第一个答案仅用作构造函数的第一个语句。第二个答案生成语法错误。第四个选项导致无限递归。 |
+| 5. | C | 第一个答案仅用作构造器的第一个语句。第二个答案生成语法错误。第四个选项导致无限递归。 |
 | 6. | A. | 抽象类不必有抽象方法，并且可以扩展其他类，无论它们是否抽象。找到实现接口的抽象类是很常见的。 |
 
-# 第 8 章：处理应用程序中的异常
+# 第 8 章：处理应用中的异常
 
 <colgroup><col style="text-align: left"> <col style="text-align: left"> <col style="text-align: left"></colgroup> 
 |