diff --git a/README.md b/README.md
index a9cbfd2..ebb4ee5 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,6 @@
- [x] 第十三章 函数式编程
- [ ] 待续······
-- 最近公司项目赶着上线,等忙完继续!
## 一起交流
diff --git a/SUMMARY.md b/SUMMARY.md
index 1a4691e..f05d997 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -85,49 +85,51 @@
* [switch字符串](book/05-Control-Flow.md#switch字符串)
* [本章小结](book/05-Control-Flow.md#本章小结)
* [第六章 初始化和清理](book/06-Housekeeping.md)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
- * [](book/06-Housekeeping.md#)
+ * [利用构造器保证初始化](book/06-Housekeeping.md#利用构造器保证初始化)
+ * [方法重载](book/06-Housekeeping.md#方法重载)
+ * [无参构造器](book/06-Housekeeping.md#无参构造器)
+ * [this关键字](book/06-Housekeeping.md#this关键字)
+ * [垃圾回收器](book/06-Housekeeping.md#垃圾回收器)
+ * [成员初始化](book/06-Housekeeping.md#成员初始化)
+ * [构造器初始化](book/06-Housekeeping.md#构造器初始化)
+ * [数组初始化](book/06-Housekeeping.md#数组初始化)
+ * [枚举类型](book/06-Housekeeping.md#枚举类型)
* [本章小结](book/06-Housekeeping.md#本章小结)
* [第七章 封装](book/07-Implementation-Hiding.md)
- * [](book/07-Implementation-Hiding.md#)
- * [](book/07-Implementation-Hiding.md#)
- * [](book/07-Implementation-Hiding.md#)
+ * [包的概念](book/07-Implementation-Hiding.md#包的概念)
+ * [访问权限修饰符](book/07-Implementation-Hiding.md#访问权限修饰符)
+ * [接口和实现](book/07-Implementation-Hiding.md#接口和实现)
+ * [类访问权限](book/07-Implementation-Hiding.md#类访问权限)
* [本章小结](book/07-Implementation-Hiding.md#本章小结)
* [第八章 复用](book/08-Reuse.md)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
- * [](book/08-Reuse.md#)
+ * [组合语法](book/08-Reuse.md#组合语法)
+ * [继承语法](book/08-Reuse.md#继承语法)
+ * [委托](book/08-Reuse.md#委托)
+ * [结合组合与继承](book/08-Reuse.md#结合组合与继承)
+ * [组合与继承的选择](book/08-Reuse.md#组合与继承的选择)
+ * [protected](book/08-Reuse.md#protected)
+ * [向上转型](book/08-Reuse.md#向上转型)
+ * [final关键字](book/08-Reuse.md#final关键字)
+ * [类初始化和加载](book/08-Reuse.md#类初始化和加载)
* [本章小结](book/08-Reuse.md#本章小结)
* [第九章 多态](book/09-Polymorphism.md)
- * [](book/09-Polymorphism.md#)
- * [](book/09-Polymorphism.md#)
- * [](book/09-Polymorphism.md#)
- * [](book/09-Polymorphism.md#)
+ * [向上转型回溯](book/09-Polymorphism.md#向上转型回溯)
+ * [深入理解](book/09-Polymorphism.md#深入理解)
+ * [构造器和多态](book/09-Polymorphism.md#构造器和多态)
+ * [返回类型协变](book/09-Polymorphism.md#返回类型协变)
+ * [使用继承设计](book/09-Polymorphism.md#使用继承设计)
* [本章小结](book/09-Polymorphism.md#本章小结)
* [第十章 接口](book/10-Interfaces.md)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
- * [](book/10-Interfaces.md#)
+ * [抽象类和方法](book/10-Interfaces.md#抽象类和方法)
+ * [接口创建](book/10-Interfaces.md#接口创建)
+ * [抽象类和接口](book/10-Interfaces.md#抽象类和接口)
+ * [完全解耦](book/10-Interfaces.md#完全解耦)
+ * [多接口结合](book/10-Interfaces.md#多接口结合)
+ * [使用继承扩展接口](book/10-Interfaces.md#使用继承扩展接口)
+ * [接口适配](book/10-Interfaces.md#接口适配)
+ * [接口字段](book/10-Interfaces.md#接口字段)
+ * [接口嵌套](book/10-Interfaces.md#接口嵌套)
+ * [接口和工厂方法模式](book/10-Interfaces.md#接口和工厂方法模式)
* [本章小结](book/10-Interfaces.md#本章小结)
* [第十一章 内部类](book/11-Inner-Classes.md)
* [](book/11-Inner-Classes.md#)
diff --git a/book/01-What-is-an-Object.md b/book/01-What-is-an-Object.md
index 684cc3f..03208fc 100644
--- a/book/01-What-is-an-Object.md
+++ b/book/01-What-is-an-Object.md
@@ -1,5 +1,5 @@
-
+[TOC]
# 第一章 对象的概念
diff --git a/book/02-Installing-Java-and-the-Book-Examples.md b/book/02-Installing-Java-and-the-Book-Examples.md
index 5003499..812ac1f 100644
--- a/book/02-Installing-Java-and-the-Book-Examples.md
+++ b/book/02-Installing-Java-and-the-Book-Examples.md
@@ -1,3 +1,5 @@
+[TOC]
+
# 第二章 安装Java和本书用例
现在，我们来为这次阅读之旅做些准备吧！
diff --git a/book/03-Objects-Everywhere.md b/book/03-Objects-Everywhere.md
index 5f0a8db..108ea35 100644
--- a/book/03-Objects-Everywhere.md
+++ b/book/03-Objects-Everywhere.md
@@ -1,3 +1,5 @@
+[TOC]
+
# 第三章 万物皆对象
>如果我们说不同的语言，我们会感觉到一个不同的世界！— Ludwig Wittgenstein (1889-1951)
@@ -469,10 +471,10 @@ Incrementable.increment（）；
// objects/HelloDate.java
import java.util.*;
- public class HelloDate {
+public class HelloDate {
public static void main(String[] args) {
- System.out.println("Hello, it's: ");
- System.out.println(new Date());
+ System.out.println("Hello, it's: ");
+ System.out.println(new Date());
}
}
@@ -488,14 +490,14 @@ import java.util.*;
现在，我们可以找到 Java 附带的每个类。使用浏览器的“查找”功能查找 “Date”。搜索结果中将会列出 java.util.Date，显而易见，它在 util 库中，所以我们必须导入 java.util.* 才能使用 Date。
-如果你在文档中选择 java.lang，然后选择 System，你会看到 System 类中有几个字段，如果你选择 `out`，你会发现它是一个静态的 PrintStream 对象。 所以，即使我们没有使用 new 创建， `out` 对象就已经存在并可以使用。 `out` 对象可以执行的操作取决于 PrintStream 。 其在文档中的描述中显示为超链接，如果单击该链接，我们将可以看到 PrintStream 所对应的方法列表。（更多详情，将在本书后面介绍。） 现在我们重点说的是 println（）这个方法。 它的作用是“j将信息输出到控制台，并以换行符结束。” 既然如此，我们可以这样编码来输出信息到控制带。 代码示例：
+如果你在文档中选择 java.lang，然后选择 System，你会看到 System 类中有几个字段，如果你选择 `out`，你会发现它是一个静态的 PrintStream 对象。 所以，即使我们没有使用 new 创建， `out` 对象就已经存在并可以使用。 `out` 对象可以执行的操作取决于 PrintStream 。 其在文档中的描述中显示为超链接，如果单击该链接，我们将可以看到 PrintStream 所对应的方法列表。（更多详情，将在本书后面介绍。） 现在我们重点说的是 println() 这个方法。 它的作用是 “将信息输出到控制台，并以换行符结束。” 既然如此，我们可以这样编码来输出信息到控制台。 代码示例：
```JAVA
System.out.println("A String of things");
```
-每个 java 源文件中允许有多个类。与此同时，源文件的名称必须要和其中一个类名相同，否则编译器将会报错。每个独立的程序应该包含一个 mian 方法作为程序运行的入口。其方法签名和返回类型如下。代码示例：
+每个 java 源文件中允许有多个类。与此同时，源文件的名称必须要和其中一个类名相同，否则编译器将会报错。每个独立的程序应该包含一个 main 方法作为程序运行的入口。其方法签名和返回类型如下。代码示例：
```JAVA
public static void main(String[] args) {
@@ -503,7 +505,7 @@ public static void main(String[] args) {
}
```
-关键字 `public` 表示方法可以被外界锁访问到。（ 更多详情将在 **隐藏实现** 章节讲到）
+关键字 `public` 表示方法可以被外界访问到。（ 更多详情将在 **隐藏实现** 章节讲到）
main() 方法的参数是一个 字符串（String） 数组。 参数 `args` 并没有在当前的程序中使用到，但是 Java 虚拟机强制要求必须要有。 这是因为它们被用于保存命令行中的参数。
下面我们来看一段有趣的代码：
@@ -520,12 +522,11 @@ System.out.println(new Date());
// objects/ShowProperties.java
public class ShowProperties {
-public static void main(String[] args) {
-System.getProperties().list(System.out);
-System.out.println(System.getProperty("user.name"));
-System.out.println(
-System.getProperty("java.library.path"));
-}
+ public static void main(String[] args) {
+ System.getProperties().list(System.out);
+ System.out.println(System.getProperty("user.name"));
+ System.out.println(System.getProperty("java.library.path"));
+ }
}
/* Output：(前20行)
@@ -597,7 +598,7 @@ class AllTheColorsOfTheRainbow {
int anIntegerRepresentingColors;
void changeTheHueOfTheColor(int newHue) {
// ...
- }
+ }
// ...
}
diff --git a/book/04-Operators.md b/book/04-Operators.md
index 5462fe1..d533b07 100644
--- a/book/04-Operators.md
+++ b/book/04-Operators.md
@@ -1,35 +1,77 @@
-# 第四章 运算符
-
[TOC]
-## [待初始化](#Using-Java-Operators)
+
+# 第四章 运算符
-## [待初始化](#Precedence)
-## [待初始化](#Assignment)
-## [待初始化](#Mathematical-Operators)
+
+## 使用说明
-## [待初始化](#Auto-Increment-and-Decrement)
-## [待初始化](#Relational-Operators)
+
+## 优先级
-## [待初始化](#Logical-Operators)
-## [待初始化](#Literals)
+
+## 赋值
-## [待初始化](#Bitwise-Operators)
-## [待初始化](#Ternary-if-else-Operator)
+
+## 算术运算符
-## [待初始化](#String-Operator-+-and-+=)
-## [待初始化](#Common-Pitfalls-When-Using-Operators)
+
+## 自动递增和递减
-## [待初始化](#Casting-Operators)
-## [待初始化](#Java-Has-No-sizeof)
+
+## 关系运算符
-## [待初始化](#A-Compendium-of-Operators)
-## [待初始化](#Summary)
\ No newline at end of file
+
+## 逻辑运算符
+
+
+
+## 字面值
+
+
+
+## 按位运算符
+
+
+
+## 移位运算符
+
+
+
+## 三元运算符
+
+
+
+## 字符串运算符
+
+
+
+## 常见陷阱
+
+
+
+## 类型转换
+
+
+
+## Java没有sizeof
+
+
+
+## 运算符总结
+
+
+
+## 本章小结
+
+
+
+
\ No newline at end of file
diff --git a/book/05-Control-Flow.md b/book/05-Control-Flow.md
index 6aac1b1..10fac11 100644
--- a/book/05-Control-Flow.md
+++ b/book/05-Control-Flow.md
@@ -1,14 +1,16 @@
+[TOC]
+
# 第五章 控制流
> 程序操纵它的世界并做出选择。 在Java中，您可以使用执行控制语句进行选择。
-Java 使用 C 的所有执行控制语句，因此如果您使用 C 或 C++ 进行编程，那么您所看到的大部分内容都是熟悉的。 大多数过程编程语言都有某种控制语句，并且语言之间经常存在重叠。在 Java 中，关键字包括 **if-else，while，do-while，for，return，break** 和名为 **switch** 的选择语句。 但是，Java并不支持备受诟病的**goto**（它仍然是解决某些类型问题的最有效方法）。 你仍然可以进行类似goto的跳转，但它比其他语言中的**goto**更受限制。
+Java 使用 C 的所有执行控制语句，因此如果您使用 C 或 C++ 进行编程，那么您所看到的大部分内容都是熟悉的。 大多数过程编程语言都有某种控制语句，并且语言之间经常存在重叠。在 Java 中，关键字包括 **if-else，while，do-while，for，return，break** 和名为 **switch** 的选择语句。 但是，Java 并不支持备受诟病的 **goto**（它仍然是解决某些类型问题的最有效方法）。 你仍然可以进行类似goto的跳转，但它比其他语言中的 **goto** 更受限制。
[TOC]
## true和flase
-条件表达式的示例是 **a == b**。这里有一个条件表达式示例，它使用条件操作符**“==”**来查看 **a**的值是否等于 **b** 的值。 表达式返回 **true** 或 **false**。 如果显示条件表达式的结果，则会生成表示布尔值的字符串 **“true”** 和 **“false”**。
+条件表达式的示例是 **a == b**。这里有一个条件表达式示例，它使用条件操作符 **==** 来查看 **a** 的值是否等于 **b** 的值。 表达式返回 **true** 或 **false**。 如果显示条件表达式的结果，则会生成表示布尔值的字符串 **true** 和 **false**。
```java
// control/TrueFalse.java
@@ -22,7 +24,7 @@ public class TrueFalse {
true false */
```
-您在上一章中看到的任何关系运算符都可以生成条件语句。 请注意，Java 不允许您使用数字作为布尔值，即使它在 C 和 C++ 中允许（在这些语言中，真"为非零，而”假“是零）。如果想在布尔测试中使用非布尔值，例如**if（a**），必须首先使用一个条件表达式将其转换为布尔值，例如 **if（a！= 0）**。
+您在上一章中看到的任何关系运算符都可以生成条件语句。 请注意，Java 不允许您使用数字作为布尔值，即使它在 C 和 C++ 中允许（在这些语言中，“真”为非零，而“假”是零）。如果想在布尔测试中使用非布尔值，例如**if (a)**，必须首先使用一个条件表达式将其转换为布尔值，例如 **if (a！= 0)**。
## if-else
@@ -74,15 +76,15 @@ public class IfElse {
*/
```
-**[1]** “else if”不是新关键字，只是一个else后跟一个新的if语句。
+**[1]** “else if” 不是新关键字，只是一个 else 后跟一个新的 if 语句。
-尽管Java（如之前的C和C ++）是一种“自由格式”语言，但通常会缩进控件流语句的主体，以便读者可以轻松确定它的开始和结束位置。
+尽管 Java（如之前的 C 和 C++）是一种“自由格式”语言，但通常会缩进控件流语句的主体，以便读者可以轻松确定它的开始和结束位置。
## 迭代语句
-循环由 **while**，**do-while** 和 **for** 控制，有时称为迭代语句。 语句会重复执行，直到起控制作用的 **布尔表达式** （Boolean expression）计算为"假"。
+循环由 **while**，**do-while** 和 **for** 控制，有时称为迭代语句。 语句会重复执行，直到起控制作用的 **布尔表达式** （Boolean expression）计算为“假”。
### while
@@ -128,7 +130,7 @@ false, Exited 'while'
*/
```
-**condition()** 方法用到了 **Math** 库里的 **static** (静态)方法 **random()**，该方法的作用是产生 0 和 1 之间 (包括 0，但不包括 1) 的一个**double**值。**result** 的值是通过比较操作符<而得到它的，这个操作符产生 **boolean** 类型的结果。在打印 **boolean** 类型的值时，将自动地得到适合的字符串 **true** 或 **false**。while 的条件表达式意思是说："只要 **condition()**返回 **true**，就重复执行循环体中的语句"。
+**condition()** 方法用到了 **Math** 库里的 **static** (静态)方法 **random()**，该方法的作用是产生 0 和 1 之间 (包括 0，但不包括 1) 的一个**double**值。**result** 的值是通过比较操作符<而得到它的，这个操作符产生 **boolean** 类型的结果。在打印 **boolean** 类型的值时，将自动地得到适合的字符串 **true** 或 **false**。while 的条件表达式意思是说：“只要 **condition()**返回 **true**，就重复执行循环体中的语句”。
### do-while
@@ -181,7 +183,7 @@ value: 106 character: j
*/
```
-请注意，变量 **c** 在程序用到它的地方被定义的，也就是在for循环的控制表达式内，而不是在 **main（）** 的开头。**c** 的范围是由 **for** 控制的语句。
+请注意，变量 **c** 在程序用到它的地方被定义的，也就是在for循环的控制表达式内，而不是在 **main()** 的开头。**c** 的范围是由 **for** 控制的语句。
像C这样的传统过程语言要求在块的开头定义所有变量。 当编译器创建块时，它可以为这些变量分配空间。 在Java和C ++中，您可以在整个块中传播变量声明，并在需要时定义它们。 这允许更自然的编码风格并使代码更容易理解。[1]
@@ -217,9 +219,9 @@ i = 4 j = 8
## for-in语法
-Java 5引入了更简洁的 **for** 语法，用于数组和集合（您将在“数组和集合”章节中了解更多有关这些内容的信息）。 这有时被称为 **增强版for循环**，并且您将看到的大部分文档称为 *for-each* 语法，但Java 8添加了大量使用的 **forEach（）**。 这会混淆术语，所以我拿了一些许可证，而是称之为*for-in* （例如，在Python中，你实际上是 **for x in sequence**，所以有合理的先例）。 请记住，您可能会在其他地方看到它的不同叫法。
+Java 5引入了更简洁的 **for** 语法，用于数组和集合（您将在“数组和集合”章节中了解更多有关这些内容的信息）。 这有时被称为 **增强版for循环**，并且您将看到的大部分文档称为 *for-each* 语法，但Java 8添加了大量使用的 **forEach()**。 这会混淆术语，因此我称之为*for-in* （例如，在Python中，你实际上是 **for x in sequence**，所以有合理的先例）。 请记住，您可能会在其他地方看到它的不同叫法。
-**for-in** 会自动为您生成每个项，因此你不必创建 **int** 变量去对由访问项构成的序列进行奇数。 例如，假设您有一个 **float** 数组，并且您想要选取该数组中的每个元素：
+**for-in** 会自动为您生成每个项，因此你不必创建 **int** 变量去对由访问项构成的序列进行计数。 例如，假设您有一个 **float** 数组，并且您想要选取该数组中的每个元素：
```java
// control/ForInFloat.java
@@ -317,9 +319,9 @@ public class ForInInt {
**range()** 方法已经被重载，重载表示相同的方法名可以具有不同的参数列表(你将很快学习重载)。**range()** 的第一个种重载形式是从0开始产生值，直到范围的上限，但不包括该上限。第二种重载形式是从第一个值开始产生值，直至比第二值小1的值为止。第三种形式有一个步进值，因此它每次的增量为该值。第四种 **range()** 表明还可以递减。**range()**是所谓生成器的一个非常简单的版本，有关生成器的内容将在本书稍后进行介绍。
-**range（）** 允许在更多地方使用for-in语法，因此可以说提高可读性。
+**range()** 允许在更多地方使用 for-in 语法，因此可以说提高可读性。
-请注意，**System.out.print（）** 不会输出换行符，因此您可以分段输出一行。
+请注意，**System.out.print()** 不会输出换行符，因此您可以分段输出一行。
*for-in* 语法不仅可以节省编写代码的时间。 更重要的是，它更容易阅读并说明你要做什么（获取数组的每个元素）而不是详细说明你是如何做到的（“我正在创建这个索引，所以我可以使用它来选择每个数组元素。“）。 本书只要有可能就会使用 *for-in* 语法。
@@ -406,7 +408,7 @@ public class BreakAndContinue {
**[2]** 使用 for-in 语法将产生相同的结果。
-**[3]** 最后，可以看到一个"无穷 **while** 循环"的情况。然而，循环内部有一个 **break** 语句，可中止循环。请注意，**continue** 语句将控制权移回循环的顶部，而不会执行 **continue** 之后的任何操作。 因此，只有当 i 的值可被 10 整除时才会显示。在输出中，显示值 0，因为 0％9 产生0。
+**[3]** 最后，可以看到一个“无穷 **while** 循环”的情况。然而，循环内部有一个 **break** 语句，可中止循环。请注意，**continue** 语句将控制权移回循环的顶部，而不会执行 **continue** 之后的任何操作。 因此，只有当 i 的值可被 10 整除时才会显示。在输出中，显示值 0，因为 0％9 产生0。
无限循环的另一种形式是 **for（;;）**。 编译器以同样的方式处理 **while（true）** 和 **for（;;）**，因此使用哪种取决于编程品味。
@@ -414,19 +416,19 @@ public class BreakAndContinue {
## 臭名昭著的goto
-goto 关键字很早就在程序设计语言中出现。事实上，goto 是汇编语言的程序控制结构的始 祖：“若条件A，则跳到这里；否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码，就 会发现程序控制里包含了许多跳转。然而，goto是在源码的级别跳转的，所以招致了不好的 声誉。若程序总是从一个地方跳到另一个地方，还有什么办法能识别代码的流程呢？随着 Edsger Dijkstra 著名的 “Goto 有害”论的问世，goto 便从此失宠。
+goto 关键字很早就在程序设计语言中出现。事实上，goto 是汇编语言的程序控制结构的始祖：“若条件A，则跳到这里；否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码，就会发现程序控制里包含了许多跳转。然而，goto是在源码的级别跳转的，所以招致了不好的声誉。若程序总是从一个地方跳到另一个地方，还有什么办法能识别代码的流程呢？随着 Edsger Dijkstra 著名的 “Goto 有害” 论的问世，goto 便从此失宠。
事实上，真正的问题并不在于使用 goto，而在于 goto 的滥用。而且在一些少见的情况下，goto 是组织控制流程的最佳手段。
-尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break和 continue 这两个关键字的身上，我们仍然能看出一些goto的影子。它并不属于一次跳 转，而是中断循环语句的一种方法。之所以把它们纳入 goto 问题中一起讨论，是由于它们使 用了相同的机制：标签。
+尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break和 continue 这两个关键字的身上，我们仍然能看出一些goto的影子。它并不属于一次跳转，而是中断循环语句的一种方法。之所以把它们纳入 goto 问题中一起讨论，是由于它们使用了相同的机制：标签。
-“标签”是后面跟一个冒号的标识符，就象下面这样：
+“标签”是后面跟一个冒号的标识符，就像下面这样：
```java
label1:
```
-对 Java 来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语 句的前方——在标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一 理由是：我们希望在其中嵌套另一个循环或者一个开关。这是由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。如下所示：
+对 Java 来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语句的前方——在标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环或者一个开关。这是由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。如下所示：
```java
label1:
@@ -446,13 +448,13 @@ outer-iteration {
**[1]** **break** 中断内部循环，并在外部循环结束。
-**[2]**，**continue** 移回内部循环的 起始处。但在条件3中，**continue label1** 却同时中断内部循环以及外部循环，并移至 **label1** 处。
+**[2]** **continue** 移回内部循环的起始处。但在条件3中，**continue label1** 却同时中断内部循环以及外部循环，并移至 **label1** 处。
-**[3]**随后，它实际是继续循环，但却从外部循环开始。
+**[3]** 随后，它实际是继续循环，但却从外部循环开始。
-**[4]**，**break label1** 也会中断所有循环，并回到 **label1** 处，但并不重新进入循环。也就是说，它实际是完全中止了两个循环。
+**[4]** **break label1** 也会中断所有循环，并回到 **label1** 处，但并不重新进入循环。也就是说，它实际是完全中止了两个循环。
-下面是for循环的一个例子：
+下面是 for 循环的一个例子：
```java
// control/LabeledFor.java
@@ -584,13 +586,13 @@ break outer
(3) **break** 会中断当前循环，并移离当前标签的末尾。
-(4) 带标签的**break**会中断当前循环，并移离由那个标签指示的循环的末尾。
+(4) 带标签的 **break** 会中断当前循环，并移离由那个标签指示的循环的末尾。
-大家要记住的重点是：在Java里需要使用标签的唯一理由就是因为有循环嵌套存在，而且想从多层嵌套中 **break** 或 **continue**。
+大家要记住的重点是：在 Java 里需要使用标签的唯一理由就是因为有循环嵌套存在，而且想从多层嵌套中 **break** 或 **continue**。
**break** 和 **continue** 标签已经成为相对少用的推测特征(在前面的语言中很少或没有先例)，所以你很少在代码里看到它们。
-在 **Dijkstra** 的 **“ goto 有害”** 论中，他最反对的就是标签，而非 **goto**。随着标签在一个程序里数量 的增多，他发现产生错误的机会也越来越多。标签和 **goto** 使我们难于对程序作静态分析。但是，Java 标签不会造成这方面的问题，因为它们的应用场合已经收到了限制，没有特别的方式用于概念程序的控制。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
+在 **Dijkstra** 的 **“goto 有害”** 论中，他最反对的就是标签，而非 **goto**。随着标签在一个程序里数量的增多，他发现产生错误的机会也越来越多。标签和 **goto** 使我们难于对程序作静态分析。但是，Java 标签不会造成这方面的问题，因为它们的应用场合已经收到了限制，没有特别的方式用于概念程序的控制。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
## switch
@@ -608,11 +610,13 @@ switch(integral-selector) {
}
```
-其中，integral-selector (整数选择因子)是一个能够产生整数值的表达式，**switch** 能够将这个表达式的结果与每个 integral-value (整数值)相比较。若发现相符的，就执行对应的语句（简单或复合语句，其中并不需要括号）。若没有发现相 符的，就执行 default 语句。
+其中，integral-selector (整数选择因子)是一个能够产生整数值的表达式，**switch** 能够将这个表达式的结果与每个 integral-value (整数值)相比较。若发现相符的，就执行对应的语句（简单或复合语句，其中并不需要括号）。若没有发现相符的，就执行 default 语句。
-在上面的定义中，大家会注意到每个 **case** 均以一个 **break** 结尾。这样可使执行流程跳转至 switch 主体的末尾。这是构建 **switch** 语句的一种传统方式，但 **break** 是可选的。若省略break， 会继续执行后面的 **case** 语句的代码，直到遇到一个 **break** 为止。尽管通常不想出现这种情况，但对有经验的程序员来说，也许能够善加利用。注意最后的 **default** 语句没有 **break**，因为执行流程已到了break的跳转目的地。当然，如果考虑到编程风格方面的原因，完全可以在**default** 语句的末尾放置一个 **break**，尽管它并没有任何实际的用处。
+在上面的定义中，大家会注意到每个 **case** 均以一个 **break** 结尾。这样可使执行流程跳转至 switch 主体的末尾。这是构建 **switch** 语句的一种传统方式，但 **break** 是可选的。若省略 break， 会继续执行后面的 **case** 语句的代码，直到遇到一个 **break** 为止。尽管通常不想出现这种情况，但对有经验的程序员来说，也许能够善加利用。注意最后的 **default** 语句没有 **break**，因为执行流程已到了break的跳转目的地。当然，如果考虑到编程风格方面的原因，完全可以在**default** 语句的末尾放置一个 **break**，尽管它并没有任何实际的用处。
-switch 语句是实现多路选择的一种干净利落的一种方式（比如从一系列执行路径中挑选一个）。但它要求使用一个选择因子，并且必须是 int 或 char 那样的整数值。例如，假若将一个字串或者浮点数 作为选择因子使用，那么它们在 switch 语句里是不会工作的。对于非整数类型，则必须使用一 系列 if 语句。 下面这个例子可随机生成字母，并判断它们是元音还是辅音字母：
+switch 语句是实现多路选择的一种干净利落的一种方式（比如从一系列执行路径中挑选一个）。但它要求使用一个选择因子，并且必须是 int 或 char 那样的整数值。例如，假若将一个字串或者浮点数作为选择因子使用，那么它们在 switch 语句里是不会工作的。对于非整数类型，则必须使用一系列 if 语句。
+
+下面这个例子可随机生成字母，并判断它们是元音还是辅音字母：
```java
// control/VowelsAndConsonants.java
@@ -659,7 +663,7 @@ z, 122: consonant
*/
```
-由于 **Random.nextInt(26)** 会产生0到26之间的一个值，所以在其上加上一个偏移量 "a"，即可产生小写字母。在 **case** 语句中，使用单引号引起的字符也会产生用于比较的整数值。
+由于 **Random.nextInt(26)** 会产生 0 到 26 之间的一个值，所以在其上加上一个偏移量 "a"，即可产生小写字母。在 **case** 语句中，使用单引号引起的字符也会产生用于比较的整数值。
请注意 **case** 语句能够堆叠在一起，为一段代码形成多重匹配，即只要符合多种条件中的一种，就执行那段特别的代码。这时也应该注意将 **break** 语句置于特定 **case** 的末尾，否则控制流程会简单地下移，处理后面的 **case**。
@@ -669,13 +673,13 @@ z, 122: consonant
int c = rand.nextInt(26) + 'a';
```
-**Random.nextInt()**将产生0~25之间的一个随机 **int** 值，它将被加到 **"a"** 上。这表示 **"a"** 将自动被转换为 **int** 以执行假发。为了把 **c** 当作字符打印，必须将其转型为 **char**；否则，将产生整数输出。
+此处 **Random.nextInt()** 将产生 0~25 之间的一个随机 **int** 值，它将被加到 **a** 上。这表示 **a** 将自动被转换为 **int** 以执行假发。为了把 **c** 当作字符打印，必须将其转型为 **char**；否则，将产生整数输出。
## switch字符串
-Java 7增加了在字符串上 **switch** 的用法。 此示例展示了您从一组String可能性中选择的旧方法，以及使用switch的新方法：
+Java 7 增加了在字符串上 **switch** 的用法。 此示例展示了您从一组 String 可能性中选择的旧方法，以及使用 switch 的新方法：
```java
// control/StringSwitch.java
@@ -721,11 +725,11 @@ RED
*/
```
-一旦理解了switch，这种语法就是一个逻辑扩展。 结果更清晰，更易于理解和维护。
+一旦理解了 switch，这种语法就是一个逻辑扩展。 结果更清晰，更易于理解和维护。
-作为 **switch** 字符串的第二个例子，我们重新访问 Math.random（）。 它是否产生从 0 到 1 的值，包括还是不包括值“1”？ 在数学术语中，是（0,1），还是[0,1]，还是（0,1）还是[0,1]？ （方括号表示“包括”，而括号表示“不包括”。）
+作为 **switch** 字符串的第二个例子，我们重新访问 Math.random()。 它是否产生从 0 到 1 的值，包括还是不包括值 “1”？ 在数学术语中，是（0,1），还是 [0,1]，还是（0,1）还是 [0,1]？ （方括号表示“包括”，而括号表示“不包括”。）
-下面一个可能提供答案的测试程序。 所有命令行参数都作为 **String** 对象传递，因此我们可以 **switch** 参数来决定要做什么。 有一个问题：用户可能不提供任何参数，因此索引到args数组会导致程序失败。 要解决这个问题，我们检查数组的长度，如果它为零，我们使用一个空字符串，否则我们选择 **args** 数组中的第一个元素：
+下面一个可能提供答案的测试程序。 所有命令行参数都作为 **String** 对象传递，因此我们可以 **switch** 参数来决定要做什么。 有一个问题：用户可能不提供任何参数，因此索引到 args 数组会导致程序失败。 要解决这个问题，我们检查数组的长度，如果它为零，我们使用一个空字符串，否则我们选择 **args** 数组中的第一个元素：
```java
// control/RandomBounds.java
@@ -766,7 +770,7 @@ or
java RandomBounds upper
```
-使用 onjava 包中的 TimedAbort 类，程序在三秒后中止，因此看起来 Math.random（）从不生成 0.0或 1.0。 但这就是这样一个实验可以欺骗的地方。 如果考虑0到1之间所有不同 **double** 类型的分数（double fractions）的数量，实验中达到任何一个值的可能性可能超过一台计算机甚至一个实验者的寿命。 结果是0.0包含在 **Math.random（）**的输出中，而 1.0 则不包括在内。 在数学术语中，它是[0,1）。 您必须小心分析您的实验并了解它们的局限性。结果是 0.0 包含在 **Math.random（）**的输出中，而 1.0 则不包括在内。 在数学术语中，它是 [0,1）。 您必须小心分析您的实验并了解它们的局限性。
+使用 onjava 包中的 TimedAbort 类，程序在三秒后中止，因此看起来 Math.random() 从不生成 0.0 或 1.0。 但这就是这样一个实验可以欺骗的地方。 如果考虑0到1之间所有不同 **double** 类型的分数（double fractions）的数量，实验中达到任何一个值的可能性可能超过一台计算机甚至一个实验者的寿命。 结果是 0.0 包含在 **Math.random()** 的输出中，而 1.0 则不包括在内。 在数学术语中，它是 [0,1）。 您必须小心分析您的实验并了解它们的局限性。结果是 0.0 包含在 **Math.random()** 的输出中，而 1.0 则不包括在内。 在数学术语中，它是 [0,1）。 您必须小心分析您的实验并了解它们的局限性。
diff --git a/book/06-Housekeeping.md b/book/06-Housekeeping.md
index 2fec7de..7178d7c 100644
--- a/book/06-Housekeeping.md
+++ b/book/06-Housekeeping.md
@@ -1,2 +1,48 @@
+[TOC]
+
+
# 第六章 初始化和清理
+
+
+## 利用构造器保证初始化
+
+
+
+## 方法重载
+
+
+
+## 无参构造器
+
+
+
+## this关键字
+
+
+
+## 垃圾回收器
+
+
+
+## 成员初始化
+
+
+
+## 构造器初始化
+
+
+
+## 数组初始化
+
+
+
+## 枚举类型
+
+
+
+## 本章小结
+
+
+
+
\ No newline at end of file
diff --git a/book/07-Implementation-Hiding.md b/book/07-Implementation-Hiding.md
index 9bd7a5d..2d13a1b 100644
--- a/book/07-Implementation-Hiding.md
+++ b/book/07-Implementation-Hiding.md
@@ -1,2 +1,31 @@
+[TOC]
+
+
# 第七章 封装
+
+
+## 包的概念
+
+
+
+## 访问权限修饰符
+
+
+
+## 接口和实现
+
+
+
+## 类访问权限
+
+
+
+## 本章小结
+
+
+
+
+
+
+
diff --git a/book/08-Reuse.md b/book/08-Reuse.md
index c0e94de..d8b7a69 100644
--- a/book/08-Reuse.md
+++ b/book/08-Reuse.md
@@ -1,2 +1,49 @@
+[TOC]
+
+
# 第八章 复用
+
+
+## 组合语法
+
+
+
+## 继承语法
+
+
+
+## 委托
+
+
+
+## 结合组合与继承
+
+
+
+## 组合与继承的选择
+
+
+
+## protected
+
+
+
+## 向上转型
+
+
+
+## final关键字
+
+
+
+## 类初始化和加载
+
+
+
+## 本章小结
+
+
+
+
+
diff --git a/book/09-Polymorphism.md b/book/09-Polymorphism.md
index c50bb40..8692dc8 100644
--- a/book/09-Polymorphism.md
+++ b/book/09-Polymorphism.md
@@ -1,2 +1,32 @@
+[TOC]
+
+
# 第九章 多态
+
+
+## 向上转型回溯
+
+
+
+## 深入理解
+
+
+
+## 构造器和多态
+
+
+
+## 返回类型协变
+
+
+
+## 使用继承设计
+
+
+
+## 本章小结
+
+
+
+
\ No newline at end of file
diff --git a/book/10-Interfaces.md b/book/10-Interfaces.md
index 9f27082..60f6bfc 100644
--- a/book/10-Interfaces.md
+++ b/book/10-Interfaces.md
@@ -1,2 +1,52 @@
+[TOC]
+
+
# 第十章 接口
+
+
+## 抽象类和方法
+
+
+
+## 接口创建
+
+
+
+## 抽象类和接口
+
+
+
+## 完全解耦
+
+
+
+## 多接口结合
+
+
+
+## 使用继承扩展接口
+
+
+
+## 接口适配
+
+
+
+## 接口字段
+
+
+
+## 接口嵌套
+
+
+
+## 接口和工厂方法模式
+
+
+
+## 本章小结
+
+
+
+
\ No newline at end of file
diff --git a/book/11-Inner-Classes.md b/book/11-Inner-Classes.md
index 5e93392..cd73576 100644
--- a/book/11-Inner-Classes.md
+++ b/book/11-Inner-Classes.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十一章 内部类
+
+
+
\ No newline at end of file
diff --git a/book/12-Collections.md b/book/12-Collections.md
index 5c5acf3..6cbc671 100644
--- a/book/12-Collections.md
+++ b/book/12-Collections.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十二章 集合
+
+
+
\ No newline at end of file
diff --git a/book/13-Functional-Programming.md b/book/13-Functional-Programming.md
index 0d44f23..097bff5 100644
--- a/book/13-Functional-Programming.md
+++ b/book/13-Functional-Programming.md
@@ -1,7 +1,7 @@
-# 第十三章-函数式编程
-
[TOC]
+# 第十三章-函数式编程
+
函数式编程语言操纵代码片段就像操作数据一样容易。 虽然 Java 不是函数式语言，但 Java 8 Lambda 表达式和方法引用 (Method References) 允许您以函数式编程。在计算机时代的早期，内存是稀缺和珍贵的。几乎每个人都用汇编语言编程。 人们对编译器有所了解，但仅仅想到编译生成的代码肯定会比手工编码多了很多字节。
@@ -1432,4 +1432,10 @@ Lambda 表达式和方法引用并没有将 Java 转换成函数式语言，而
6. 在并发编程一章中，当您理解更改共享变量 “不是线程安全的” 时，这将更有意义。
7. 接口能够支持方法的原因是它们是 Java 8 默认方法，您将在下一章中了解到。
8. 一些语言，例如 Python，允许像调用其他函数一样调用组合函数。但这是 Java，所以我们取我们能得到的。
-9. 见,例如，不可变和可变性检测器。( Immutables and Mutability Detector)
\ No newline at end of file
+9. 见,例如，不可变和可变性检测器。( Immutables and Mutability Detector)
+
+
+
+
+
+
\ No newline at end of file
diff --git a/book/14-Streams.md b/book/14-Streams.md
index f9ec406..3896ebb 100644
--- a/book/14-Streams.md
+++ b/book/14-Streams.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十四章 流式编程
+
+
+
\ No newline at end of file
diff --git a/book/15-Exceptions.md b/book/15-Exceptions.md
index b66472a..2b192fd 100644
--- a/book/15-Exceptions.md
+++ b/book/15-Exceptions.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十五章 异常
+
+
+
\ No newline at end of file
diff --git a/book/16-Validating-Your-Code.md b/book/16-Validating-Your-Code.md
index dfd2aba..ad57fd0 100644
--- a/book/16-Validating-Your-Code.md
+++ b/book/16-Validating-Your-Code.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十六章 代码校验
+
+
+
\ No newline at end of file
diff --git a/book/17-Files.md b/book/17-Files.md
index a1230cf..b4ed539 100644
--- a/book/17-Files.md
+++ b/book/17-Files.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十七章 文件
+
+
+
\ No newline at end of file
diff --git a/book/18-Strings.md b/book/18-Strings.md
index 9252da2..bd07bf6 100644
--- a/book/18-Strings.md
+++ b/book/18-Strings.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十八章 字符串
+
+
+
\ No newline at end of file
diff --git a/book/19-Type-Information.md b/book/19-Type-Information.md
index 5929f73..4c1627b 100644
--- a/book/19-Type-Information.md
+++ b/book/19-Type-Information.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第十九章 类型信息
+
+
+
\ No newline at end of file
diff --git a/book/20-Generics.md b/book/20-Generics.md
index 4bb7980..965b1dc 100644
--- a/book/20-Generics.md
+++ b/book/20-Generics.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第二十章 泛型
+
+
+
\ No newline at end of file
diff --git a/book/21-Arrays.md b/book/21-Arrays.md
index 38e066e..bea68df 100644
--- a/book/21-Arrays.md
+++ b/book/21-Arrays.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第二十一章 数组
+
+
+
\ No newline at end of file
diff --git a/book/22-Enumerations.md b/book/22-Enumerations.md
index 999ad7c..34a9048 100644
--- a/book/22-Enumerations.md
+++ b/book/22-Enumerations.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第二十二章 枚举
+
+
+
\ No newline at end of file
diff --git a/book/23-Annotations.md b/book/23-Annotations.md
index d30be18..81e3a7f 100644
--- a/book/23-Annotations.md
+++ b/book/23-Annotations.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第二十三章 注解
+
+
+
\ No newline at end of file
diff --git a/book/24-Concurrent-Programming.md b/book/24-Concurrent-Programming.md
index ab865da..bc15d3f 100644
--- a/book/24-Concurrent-Programming.md
+++ b/book/24-Concurrent-Programming.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第二十四章 并发编程
+
+
+
\ No newline at end of file
diff --git a/book/25-Patterns.md b/book/25-Patterns.md
index ea3ca32..713c00f 100644
--- a/book/25-Patterns.md
+++ b/book/25-Patterns.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 第二十五章 正则表达式
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Becoming-a-Programmer.md b/book/Appendix-Becoming-a-Programmer.md
index 79cc6c2..4fe1fd1 100644
--- a/book/Appendix-Becoming-a-Programmer.md
+++ b/book/Appendix-Becoming-a-Programmer.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:成为一名程序员
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Benefits-and-Costs-of-Static-Type-Checking.md b/book/Appendix-Benefits-and-Costs-of-Static-Type-Checking.md
index 64468e5..01c0cd8 100644
--- a/book/Appendix-Benefits-and-Costs-of-Static-Type-Checking.md
+++ b/book/Appendix-Benefits-and-Costs-of-Static-Type-Checking.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:静态语言类型检查
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Collection-Topics.md b/book/Appendix-Collection-Topics.md
index f10136b..57ea342 100644
--- a/book/Appendix-Collection-Topics.md
+++ b/book/Appendix-Collection-Topics.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:集合主题
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Data-Compression.md b/book/Appendix-Data-Compression.md
index e7f1015..d264088 100644
--- a/book/Appendix-Data-Compression.md
+++ b/book/Appendix-Data-Compression.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:数据压缩
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-IO-Streams.md b/book/Appendix-IO-Streams.md
index bc03ea3..51fd15c 100644
--- a/book/Appendix-IO-Streams.md
+++ b/book/Appendix-IO-Streams.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:流式IO
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Javadoc.md b/book/Appendix-Javadoc.md
index 0c985fc..3337039 100644
--- a/book/Appendix-Javadoc.md
+++ b/book/Appendix-Javadoc.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:文档注释
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Low-Level-Concurrency.md b/book/Appendix-Low-Level-Concurrency.md
index 9a8c3a7..3441e7a 100644
--- a/book/Appendix-Low-Level-Concurrency.md
+++ b/book/Appendix-Low-Level-Concurrency.md
@@ -1,2 +1,4 @@
+[TOC]
+
# 附录:并发底层原理
diff --git a/book/Appendix-New-IO.md b/book/Appendix-New-IO.md
index 816c0f8..e4bcbac 100644
--- a/book/Appendix-New-IO.md
+++ b/book/Appendix-New-IO.md
@@ -1,5 +1,8 @@
+[TOC]
+
# 附录:新IO
+
Java “新” I/O 库，是在Java 1.4引入到 **Java .nio.* package** 中。它有一个目标 : 速度。
实际上，“旧的”I/O包是使用 **nio** 重新实现了，因此速度也得到提升，因此即使不显式地使用nio 编写代码，也可以提速。这种速度的提高既发生在文件 I/O 中(这里讨论)，也发生在网络I/O 中(例如用于Internet编程)。
@@ -983,4 +986,8 @@ Released: 0 to 50331647
-1. 您可以在附录:低级并发中找到关于线程的更多细节。
\ No newline at end of file
+1. 您可以在附录:低级并发中找到关于线程的更多细节。
+=======
+
+
+
diff --git a/book/Appendix-Object-Serialization.md b/book/Appendix-Object-Serialization.md
index d9699b9..3f60e3c 100644
--- a/book/Appendix-Object-Serialization.md
+++ b/book/Appendix-Object-Serialization.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:对象序列化
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Passing-and-Returning-Objects.md b/book/Appendix-Passing-and-Returning-Objects.md
index 8cff3e7..b2a45a0 100644
--- a/book/Appendix-Passing-and-Returning-Objects.md
+++ b/book/Appendix-Passing-and-Returning-Objects.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:对象传递和返回
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Programming-Guidelines.md b/book/Appendix-Programming-Guidelines.md
index ebbb6e8..0bf4676 100644
--- a/book/Appendix-Programming-Guidelines.md
+++ b/book/Appendix-Programming-Guidelines.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:编程指南
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Standard-IO.md b/book/Appendix-Standard-IO.md
index d92be15..96da9bc 100644
--- a/book/Appendix-Standard-IO.md
+++ b/book/Appendix-Standard-IO.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:标准IO
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-Supplements.md b/book/Appendix-Supplements.md
index e58d28d..ca98d3c 100644
--- a/book/Appendix-Supplements.md
+++ b/book/Appendix-Supplements.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:补充
+
+
+
\ No newline at end of file
diff --git a/book/Appendix-The-Positive-Legacy-of-C-plus-plus-and-Java.md b/book/Appendix-The-Positive-Legacy-of-C-plus-plus-and-Java.md
index 71ff160..f35da00 100644
--- a/book/Appendix-The-Positive-Legacy-of-C-plus-plus-and-Java.md
+++ b/book/Appendix-The-Positive-Legacy-of-C-plus-plus-and-Java.md
@@ -1,2 +1,8 @@
+[TOC]
+
# 附录:C++和Java的优良传统
+
+
+
+
diff --git a/book/Appendix-Understanding-equals-and-hashCode.md b/book/Appendix-Understanding-equals-and-hashCode.md
index d3ee4cd..15e2fa5 100644
--- a/book/Appendix-Understanding-equals-and-hashCode.md
+++ b/book/Appendix-Understanding-equals-and-hashCode.md
@@ -1,2 +1,7 @@
+[TOC]
+
# 附录:理解equals和hashCode方法
+
+
+
\ No newline at end of file