4.1~3

4.1 用构建器自动初始化.md

 # 4.1 用构造器自动初始化
 
 
-对于方法的创建，可将其想象成为自己写的每个类都调用一次initialize()。这个名字提醒我们在使用对象之前，应首先进行这样的调用。但不幸的是，这也意味着用户必须记住调用方法。在Java中，由于提供了名为“构造器”的一种特殊方法，所以类的设计者可担保每个对象都会得到正确的初始化。若某个类有一个构造器，那么在创建对象时，Java会自动调用那个构造器——甚至在用户毫不知觉的情况下。所以说这是可以担保的！
+对于方法的创建，可将其想象成为自己写的每个类都调用一次`initialize()`。这个名字提醒我们在使用对象之前，应首先进行这样的调用。但不幸的是，这也意味着用户必须记住调用方法。在Java中，由于提供了名为“构造器”的一种特殊方法，所以类的设计者可担保每个对象都会得到正确的初始化。若某个类有一个构造器，那么在创建对象时，Java会自动调用那个构造器——甚至在用户毫不知觉的情况下。所以说这是可以担保的！
 
 接着的一个问题是如何命名这个方法。存在两方面的问题。第一个是我们使用的任何名字都可能与打算为某个类成员使用的名字冲突。第二是由于编译器的责任是调用构造器，所以它必须知道要调用是哪个方法。C++采取的方案看来是最简单的，且更有逻辑性，所以也在Java里得到了应用：构造器的名字与类名相同。这样一来，可保证象这样的一个方法会在初始化期间自动调用。
 
@@ -53,13 +53,13 @@ public class SimpleConstructor {
 ```
 
 
-利用构造器的参数，我们可为一个对象的初始化设定相应的参数。举个例子来说，假设类Tree有一个构造器，它用一个整数参数标记树的高度，那么就可以象下面这样创建一个Tree对象：
+利用构造器的参数，我们可为一个对象的初始化设定相应的参数。举个例子来说，假设类`Tree`有一个构造器，它用一个整数参数标记树的高度，那么就可以象下面这样创建一个`Tree`对象：
 
 ```
 tree t = new Tree(12); // 12英尺高的树
 ```
 
-若Tree(int)是我们唯一的构造器，那么编译器不会允许我们以其他任何方式创建一个Tree对象。
+若`Tree(int)`是我们唯一的构造器，那么编译器不会允许我们以其他任何方式创建一个`Tree`对象。
 
-构造器有助于消除大量涉及类的问题，并使代码更易阅读。例如在前述的代码段中，我们并未看到对initialize()方法的明确调用——那些方法在概念上独立于定义内容。在Java中，定义和初始化属于统一的概念——两者缺一不可。
-构造器属于一种较特殊的方法类型，因为它没有返回值。这与void返回值存在着明显的区别。对于void返回值，尽管方法本身不会自动返回什么，但仍然可以让它返回另一些东西。构造器则不同，它不仅什么也不会自动返回，而且根本不能有任何选择。若存在一个返回值，而且假设我们可以自行选择返回内容，那么编译器多少要知道如何对那个返回值作什么样的处理。
+构造器有助于消除大量涉及类的问题，并使代码更易阅读。例如在前述的代码段中，我们并未看到对`initialize()`方法的明确调用——那些方法在概念上独立于定义内容。在Java中，定义和初始化属于统一的概念——两者缺一不可。
+构造器属于一种较特殊的方法类型，因为它没有返回值。这与`void`返回值存在着明显的区别。对于`void`返回值，尽管方法本身不会自动返回什么，但仍然可以让它返回另一些东西。构造器则不同，它不仅什么也不会自动返回，而且根本不能有任何选择。若存在一个返回值，而且假设我们可以自行选择返回内容，那么编译器多少要知道如何对那个返回值作什么样的处理。

4.2 方法过载.md

@@ -7,7 +7,7 @@
 
 将人类语言中存在细致差别的概念“映射”到一种程序设计语言中时，会出现一些特殊的问题。在日常生活中，我们用相同的词表达多种不同的含义——即词的“重载”。我们说“洗衬衫”、“洗车”以及“洗狗”。但若强制象下面这样说，就显得很愚蠢：“衬衫洗 衬衫”、“车洗 车”以及“狗洗 狗”。这是由于听众根本不需要对执行的行动作任何明确的区分。人类的大多数语言都具有很强的“冗余”性，所以即使漏掉了几个词，仍然可以推断出含义。我们不需要独一无二的标识符——可从具体的语境中推论出含义。
 
-大多数程序设计语言（特别是C）要求我们为每个函数都设定一个独一无二的标识符。所以绝对不能用一个名为print()的函数来显示整数，再用另一个print()显示浮点数——每个函数都要求具备唯一的名字。
+大多数程序设计语言（特别是C）要求我们为每个函数都设定一个独一无二的标识符。所以绝对不能用一个名为`print()`的函数来显示整数，再用另一个`print()`显示浮点数——每个函数都要求具备唯一的名字。
 
 在Java里，另一项因素强迫方法名出现重载情况：构造器。由于构造器的名字由类名决定，所以只能有一个构造器名称。但假若我们想用多种方式创建一个对象呢？例如，假设我们想创建一个类，令其用标准方式进行初始化，另外从文件里读取信息来初始化。此时，我们需要两个构造器，一个没有参数（默认构造器），另一个将字串作为参数——用于初始化对象的那个文件的名字。由于都是构造器，所以它们必须有相同的名字，亦即类名。所以为了让相同的方法名伴随不同的参数类型使用，“方法重载”是非常关键的一项措施。同时，尽管方法重载是构造器必需的，但它亦可应用于其他任何方法，且用法非常方便。
 
@@ -56,11 +56,11 @@ public class Overloading {
 } ///:~
 ```
 
-Tree既可创建成一颗种子，不含任何参数；亦可创建成生长在苗圃中的植物。为支持这种创建，共使用了两个构造器，一个没有参数（我们把没有参数的构造器称作“默认构造器”，注释①），另一个采用现成的高度。
+`Tree`既可创建成一颗种子，不含任何参数；亦可创建成生长在苗圃中的植物。为支持这种创建，共使用了两个构造器，一个没有参数（我们把没有参数的构造器称作“默认构造器”，注释①），另一个采用现成的高度。
 
 ①：在Sun公司出版的一些Java资料中，用简陋但很说明问题的词语称呼这类构造器——“无参数构造器”（no-arg constructors）。但“默认构造器”这个称呼已使用了许多年，所以我选择了它。
 
-我们也有可能希望通过多种途径调用info()方法。例如，假设我们有一条额外的消息想显示出来，就使用String参数；而假设没有其他话可说，就不使用。由于为显然相同的概念赋予了两个独立的名字，所以看起来可能有些古怪。幸运的是，方法重载允许我们为两者使用相同的名字。
+我们也有可能希望通过多种途径调用`info()`方法。例如，假设我们有一条额外的消息想显示出来，就使用`String`参数；而假设没有其他话可说，就不使用。由于为显然相同的概念赋予了两个独立的名字，所以看起来可能有些古怪。幸运的是，方法重载允许我们为两者使用相同的名字。
 
 4.2.1 区分重载方法
 
@@ -91,7 +91,7 @@ public class OverloadingOrder {
 } ///:~
 ```
 
-两个print()方法有完全一致的参数，但顺序不同，可据此区分它们。
+两个`print()`方法有完全一致的参数，但顺序不同，可据此区分它们。
 
 4.2.2 基本类型的重载
 
@@ -103,8 +103,8 @@ public class OverloadingOrder {
 
 public class PrimitiveOverloading {
   // boolean can't be automatically converted
-  static void prt(String s) { 
-    System.out.println(s); 
+  static void prt(String s) {
+    System.out.println(s);
   }
 
   void f1(char x) { prt("f1(char)"); }
@@ -182,7 +182,7 @@ public class PrimitiveOverloading {
     f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);
   }
   public static void main(String[] args) {
-    PrimitiveOverloading p = 
+    PrimitiveOverloading p =
       new PrimitiveOverloading();
     p.testConstVal();
     p.testChar();
@@ -196,7 +196,7 @@ public class PrimitiveOverloading {
 } ///:~
 ```
 
-若观察这个程序的输出，就会发现常数值5被当作一个int值处理。所以假若可以使用一个重载的方法，就能获取它使用的int值。在其他所有情况下，若我们的数据类型“小于”方法中使用的参数，就会对那种数据类型进行“转型”处理。char获得的效果稍有些不同，这是由于假期它没有发现一个准确的char匹配，就会转型为int。
+若观察这个程序的输出，就会发现常数值5被当作一个`int`值处理。所以假若可以使用一个重载的方法，就能获取它使用的`int`值。在其他所有情况下，若我们的数据类型“小于”方法中使用的参数，就会对那种数据类型进行“转型”处理。`char`获得的效果稍有些不同，这是由于假期它没有发现一个准确的`char`匹配，就会转型为`int`。
 若我们的参数“大于”重载方法期望的参数，这时又会出现什么情况呢？对前述程序的一个修改揭示出了答案：
 
 ```
@@ -204,8 +204,8 @@ public class PrimitiveOverloading {
 // Demotion of primitives and overloading
 
 public class Demotion {
-  static void prt(String s) { 
-    System.out.println(s); 
+  static void prt(String s) {
+    System.out.println(s);
   }
 
   void f1(char x) { prt("f1(char)"); }
@@ -269,13 +269,13 @@ void f() {}
 int f() {}
 ```
 
-若编译器可根据上下文（语境）明确判断出含义，比如在int x=f()中，那么这样做完全没有问题。然而，我们也可能调用一个方法，同时忽略返回值；我们通常把这称为“为它的副作用去调用一个方法”，因为我们关心的不是返回值，而是方法调用的其他效果。所以假如我们象下面这样调用方法：
+若编译器可根据上下文（语境）明确判断出含义，比如在`int x=f()`中，那么这样做完全没有问题。然而，我们也可能调用一个方法，同时忽略返回值；我们通常把这称为“为它的副作用去调用一个方法”，因为我们关心的不是返回值，而是方法调用的其他效果。所以假如我们象下面这样调用方法：
 
 ```
 f();
 ```
 
-Java怎样判断f()的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能根据返回值类型来区分重载的方法。
+Java怎样判断`f()`的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能根据返回值类型来区分重载的方法。
 
 4.2.4 默认构造器
 
@@ -318,9 +318,9 @@ new Bush();
 
 编译程序就会报告自己找不到一个相符的构造器。就好象我们没有设置任何构造器，编译程序会说：“你看来似乎需要一个构造器，所以让我们给你制造一个吧。”但假如我们写了一个构造器，编译程序就会说：“啊，你已写了一个构造器，所以我知道你想干什么；如果你不放置一个默认的，是由于你打算省略它。”
 
-4.2.5 this关键字
+4.2.5 `this`关键字
 
-如果有两个同类型的对象，分别叫作a和b，那么您也许不知道如何为这两个对象同时调用一个f()方法：
+如果有两个同类型的对象，分别叫作`a`和`b`，那么您也许不知道如何为这两个对象同时调用一个`f()`方法：
 
 ```
 class Banana { void f(int i) { /* ... */ } }
@@ -329,9 +329,9 @@ a.f(1);
 b.f(2);
 ```
 
-若只有一个名叫f()的方法，它怎样才能知道自己是为a还是为b调用的呢？
+若只有一个名叫`f()`的方法，它怎样才能知道自己是为`a`还是为`b`调用的呢？
 
-为了能用简便的、面向对象的语法来书写代码——亦即“将消息发给对象”，编译器为我们完成了一些幕后工作。其中的秘密就是第一个参数传递给方法f()，而且那个参数是准备操作的那个对象的引用。所以前述的两个方法调用就变成了下面这样的形式：
+为了能用简便的、面向对象的语法来书写代码——亦即“将消息发给对象”，编译器为我们完成了一些幕后工作。其中的秘密就是第一个参数传递给方法`f()`，而且那个参数是准备操作的那个对象的引用。所以前述的两个方法调用就变成了下面这样的形式：
 
 ```
 Banana.f(a,1);
@@ -340,7 +340,7 @@ Banana.f(b,2);
 
 这是内部的表达形式，我们并不能这样书写表达式，并试图让编译器接受它。但是，通过它可理解幕后到底发生了什么事情。
 
-假定我们在一个方法的内部，并希望获得当前对象的引用。由于那个引用是由编译器“秘密”传递的，所以没有标识符可用。然而，针对这一目的有个专用的关键字：this。this关键字（注意只能在方法内部使用）可为已调用了其方法的那个对象生成相应的引用。可象对待其他任何对象引用一样对待这个引用。但要注意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用this。只需简单地调用那个方法即可。当前的this引用会自动应用于其他方法。所以我们能使用下面这样的代码：
+假定我们在一个方法的内部，并希望获得当前对象的引用。由于那个引用是由编译器“秘密”传递的，所以没有标识符可用。然而，针对这一目的有个专用的关键字：`this`。`this`关键字（注意只能在方法内部使用）可为已调用了其方法的那个对象生成相应的引用。可象对待其他任何对象引用一样对待这个引用。但要注意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用`this`。只需简单地调用那个方法即可。当前的`this`引用会自动应用于其他方法。所以我们能使用下面这样的代码：
 
 ```
 class Apricot {
@@ -349,7 +349,7 @@ void pit() { pick(); /* ... */ }
 }
 ```
 
-在pit()内部，我们可以说this.pick()，但事实上无此必要。编译器能帮我们自动完成。this关键字只能用于那些特殊的类——需明确使用当前对象的引用。例如，假若您希望将引用返回给当前对象，那么它经常在return语句中使用。
+在`pit()`内部，我们可以说`this.pick()`，但事实上无此必要。编译器能帮我们自动完成。`this`关键字只能用于那些特殊的类——需明确使用当前对象的引用。例如，假若您希望将引用返回给当前对象，那么它经常在`return`语句中使用。
 
 ```
 //: Leaf.java
@@ -371,13 +371,13 @@ public class Leaf {
 } ///:~
 ```
 
-由于increment()通过this关键字返回当前对象的引用，所以可以方便地对同一个对象执行多项操作。
+由于`increment()`通过`this`关键字返回当前对象的引用，所以可以方便地对同一个对象执行多项操作。
 
 1. 在构造器里调用构造器
 
-若为一个类写了多个构造器，那么经常都需要在一个构造器里调用另一个构造器，以避免写重复的代码。可用this关键字做到这一点。
+若为一个类写了多个构造器，那么经常都需要在一个构造器里调用另一个构造器，以避免写重复的代码。可用`this`关键字做到这一点。
 
-通常，当我们说this的时候，都是指“这个对象”或者“当前对象”。而且它本身会产生当前对象的一个引用。在一个构造器中，若为其赋予一个参数列表，那么this关键字会具有不同的含义：它会对与那个参数列表相符的构造器进行明确的调用。这样一来，我们就可通过一条直接的途径来调用其他构造器。如下所示：
+通常，当我们说`this`的时候，都是指“这个对象”或者“当前对象”。而且它本身会产生当前对象的一个引用。在一个构造器中，若为其赋予一个参数列表，那么`this`关键字会具有不同的含义：它会对与那个参数列表相符的构造器进行明确的调用。这样一来，我们就可通过一条直接的途径来调用其他构造器。如下所示：
 
 ```
 //: Flower.java
@@ -420,16 +420,16 @@ public class Flower {
 } ///:~
 ```
 
-其中，构造器Flower(String s,int petals)向我们揭示出这样一个问题：尽管可用this调用一个构造器，但不可调用两个。除此以外，构造器调用必须是我们做的第一件事情，否则会收到编译程序的报错信息。
+其中，构造器`Flower(String s,int petals)`向我们揭示出这样一个问题：尽管可用`this`调用一个构造器，但不可调用两个。除此以外，构造器调用必须是我们做的第一件事情，否则会收到编译程序的报错信息。
 
-这个例子也向大家展示了this的另一项用途。由于参数s的名字以及成员数据s的名字是相同的，所以会出现混淆。为解决这个问题，可用this.s来引用成员数据。经常都会在Java代码里看到这种形式的应用，本书的大量地方也采用了这种做法。
+这个例子也向大家展示了`this`的另一项用途。由于参数`s`的名字以及成员数据`s`的名字是相同的，所以会出现混淆。为解决这个问题，可用`this.s`来引用成员数据。经常都会在Java代码里看到这种形式的应用，本书的大量地方也采用了这种做法。
 
-在print()中，我们发现编译器不让我们从除了一个构造器之外的其他任何方法内部调用一个构造器。
+在`print()`中，我们发现编译器不让我们从除了一个构造器之外的其他任何方法内部调用一个构造器。
 
-2. static的含义
+2. `static`的含义
 
-理解了this关键字后，我们可更完整地理解static（静态）方法的含义。它意味着一个特定的方法没有this。我们不可从一个static方法内部发出对非static方法的调用（注释②），尽管反过来说是可以的。而且在没有任何对象的前提下，我们可针对类本身发出对一个static方法的调用。事实上，那正是static方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C语言中）。除了全局函数不允许在Java中使用以外，若将一个static方法置入一个类的内部，它就可以访问其他static方法以及static字段。
+理解了`this`关键字后，我们可更完整地理解`static`（静态）方法的含义。它意味着一个特定的方法没有`this`。我们不可从一个`static`方法内部发出对非`static`方法的调用（注释②），尽管反过来说是可以的。而且在没有任何对象的前提下，我们可针对类本身发出对一个`static`方法的调用。事实上，那正是`static`方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C语言中）。除了全局函数不允许在Java中使用以外，若将一个`static`方法置入一个类的内部，它就可以访问其他`static`方法以及`static`字段。
 
-②：有可能发出这类调用的一种情况是我们将一个对象引用传到static方法内部。随后，通过引用（此时实际是this），我们可调用非static方法，并访问非static字段。但一般地，如果真的想要这样做，只要制作一个普通的、非static方法即可。
+②：有可能发出这类调用的一种情况是我们将一个对象引用传到`static`方法内部。随后，通过引用（此时实际是`this`），我们可调用非`static`方法，并访问非`static`字段。但一般地，如果真的想要这样做，只要制作一个普通的、非`static`方法即可。
 
-有些人抱怨static方法并不是“面向对象”的，因为它们具有全局函数的某些特点；利用static方法，我们不必向对象发送一条消息，因为不存在this。这可能是一个清楚的参数，若您发现自己使用了大量静态方法，就应重新思考自己的策略。然而，static的概念是非常实用的，许多时候都需要用到它。所以至于它们是否真的“面向对象”，应该留给理论家去讨论。事实上，即使Smalltalk在自己的“类方法”里也有类似于static的东西。
+有些人抱怨`static`方法并不是“面向对象”的，因为它们具有全局函数的某些特点；利用`static`方法，我们不必向对象发送一条消息，因为不存在`this`。这可能是一个清楚的参数，若您发现自己使用了大量静态方法，就应重新思考自己的策略。然而，`static`的概念是非常实用的，许多时候都需要用到它。所以至于它们是否真的“面向对象”，应该留给理论家去讨论。事实上，即使Smalltalk在自己的“类方法”里也有类似于`static`的东西。

4.3 清除：收尾和垃圾收集.md

 # 4.3 清除：收尾和垃圾收集
 
 
-程序员都知道“初始化”的重要性，但通常忘记清除的重要性。毕竟，谁需要来清除一个int呢？但是对于库来说，用完后简单地“释放”一个对象并非总是安全的。当然，Java可用垃圾收集器回收由不再使用的对象占据的内存。现在考虑一种非常特殊且不多见的情况。假定我们的对象分配了一个“特殊”内存区域，没有使用new。垃圾收集器只知道释放那些由new分配的内存，所以不知道如何释放对象的“特殊”内存。为解决这个问题，Java提供了一个名为finalize()的方法，可为我们的类定义它。在理想情况下，它的工作原理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存。所以如果使用finalize()，就可以在垃圾收集期间进行一些重要的清除或清扫工作。
+程序员都知道“初始化”的重要性，但通常忘记清除的重要性。毕竟，谁需要来清除一个`int`呢？但是对于库来说，用完后简单地“释放”一个对象并非总是安全的。当然，Java可用垃圾收集器回收由不再使用的对象占据的内存。现在考虑一种非常特殊且不多见的情况。假定我们的对象分配了一个“特殊”内存区域，没有使用`new`。垃圾收集器只知道释放那些由`new`分配的内存，所以不知道如何释放对象的“特殊”内存。为解决这个问题，Java提供了一个名为`finalize()`的方法，可为我们的类定义它。在理想情况下，它的工作原理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用`finalize()`，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存。所以如果使用`finalize()`，就可以在垃圾收集期间进行一些重要的清除或清扫工作。
 
-但也是一个潜在的编程陷阱，因为有些程序员（特别是在C++开发背景的）刚开始可能会错误认为它就是在C++中为“破坏器”（Destructor）使用的finalize()——破坏（清除）一个对象的时候，肯定会调用这个函数。但在这里有必要区分一下C++和Java的区别，因为C++的对象肯定会被清除（排开编程错误的因素），而Java对象并非肯定能作为垃圾被“收集”去。或者换句话说：
+但也是一个潜在的编程陷阱，因为有些程序员（特别是在C++开发背景的）刚开始可能会错误认为它就是在C++中为“破坏器”（Destructor）使用的`finalize()`——破坏（清除）一个对象的时候，肯定会调用这个函数。但在这里有必要区分一下C++和Java的区别，因为C++的对象肯定会被清除（排开编程错误的因素），而Java对象并非肯定能作为垃圾被“收集”去。或者换句话说：
 
 垃圾收集并不等于“破坏”！
 
-若能时刻牢记这一点，踩到陷阱的可能性就会大大减少。它意味着在我们不再需要一个对象之前，有些行动是必须采取的，而且必须由自己来采取这些行动。Java并未提供“破坏器”或者类似的概念，所以必须创建一个原始的方法，用它来进行这种清除。例如，假设在对象创建过程中，它会将自己描绘到屏幕上。如果不从屏幕明确删除它的图像，那么它可能永远都不会被清除。若在finalize()里置入某种删除机制，那么假设对象被当作垃圾收掉了，图像首先会将自身从屏幕上移去。但若未被收掉，图像就会保留下来。所以要记住的第二个重点是：
+若能时刻牢记这一点，踩到陷阱的可能性就会大大减少。它意味着在我们不再需要一个对象之前，有些行动是必须采取的，而且必须由自己来采取这些行动。Java并未提供“破坏器”或者类似的概念，所以必须创建一个原始的方法，用它来进行这种清除。例如，假设在对象创建过程中，它会将自己描绘到屏幕上。如果不从屏幕明确删除它的图像，那么它可能永远都不会被清除。若在`finalize()`里置入某种删除机制，那么假设对象被当作垃圾收掉了，图像首先会将自身从屏幕上移去。但若未被收掉，图像就会保留下来。所以要记住的第二个重点是：
 
 我们的对象可能不会当作垃圾被收掉！
 
 有时可能发现一个对象的存储空间永远都不会释放，因为自己的程序永远都接近于用光空间的临界点。若程序执行结束，而且垃圾收集器一直都没有释放我们创建的任何对象的存储空间，则随着程序的退出，那些资源会返回给操作系统。这是一件好事情，因为垃圾收集本身也要消耗一些开销。如永远都不用它，那么永远也不用支出这部分开销。
 
-4.3.1 finalize()用途何在
+4.3.1 `finalize()`用途何在
 
-此时，大家可能已相信了自己应该将finalize()作为一种常规用途的清除方法使用。它有什么好处呢？
+此时，大家可能已相信了自己应该将`finalize()`作为一种常规用途的清除方法使用。它有什么好处呢？
 要记住的第三个重点是：
 
 垃圾收集只跟内存有关！
 
-也就是说，垃圾收集器存在的唯一原因是为了回收程序不再使用的内存。所以对于与垃圾收集有关的任何活动来说，其中最值得注意的是finalize()方法，它们也必须同内存以及它的回收有关。
+也就是说，垃圾收集器存在的唯一原因是为了回收程序不再使用的内存。所以对于与垃圾收集有关的任何活动来说，其中最值得注意的是`finalize()`方法，它们也必须同内存以及它的回收有关。
 
-但这是否意味着假如对象包含了其他对象，finalize()就应该明确释放那些对象呢？答案是否定的——垃圾收集器会负责释放所有对象占据的内存，无论这些对象是如何创建的。它将对finalize()的需求限制到特殊的情况。在这种情况下，我们的对象可采用与创建对象时不同的方法分配一些存储空间。但大家或许会注意到，Java中的所有东西都是对象，所以这到底是怎么一回事呢？
+但这是否意味着假如对象包含了其他对象，`finalize()`就应该明确释放那些对象呢？答案是否定的——垃圾收集器会负责释放所有对象占据的内存，无论这些对象是如何创建的。它将对`finalize()`的需求限制到特殊的情况。在这种情况下，我们的对象可采用与创建对象时不同的方法分配一些存储空间。但大家或许会注意到，Java中的所有东西都是对象，所以这到底是怎么一回事呢？
 
-之所以要使用finalize()，看起来似乎是由于有时需要采取与Java的普通方法不同的一种方法，通过分配内存来做一些具有C风格的事情。这主要可以通过“固有方法”来进行，它是从Java里调用非Java方法的一种方式（固有方法的问题在附录A讨论）。C和C++是目前唯一获得固有方法支持的语言。但由于它们能调用通过其他语言编写的子程序，所以能够有效地调用任何东西。在非Java代码内部，也许能调用C的malloc()系列函数，用它分配存储空间。而且除非调用了free()，否则存储空间不会得到释放，从而造成内存“漏洞”的出现。当然，free()是一个C和C++函数，所以我们需要在finalize()内部的一个固有方法中调用它。
+之所以要使用`finalize()`，看起来似乎是由于有时需要采取与Java的普通方法不同的一种方法，通过分配内存来做一些具有C风格的事情。这主要可以通过“固有方法”来进行，它是从Java里调用非Java方法的一种方式（固有方法的问题在附录A讨论）。C和C++是目前唯一获得固有方法支持的语言。但由于它们能调用通过其他语言编写的子程序，所以能够有效地调用任何东西。在非Java代码内部，也许能调用C的`malloc()`系列函数，用它分配存储空间。而且除非调用了`free()`，否则存储空间不会得到释放，从而造成内存“漏洞”的出现。当然，`free()`是一个C和C++函数，所以我们需要在`finalize()`内部的一个固有方法中调用它。
 
-读完上述文字后，大家或许已弄清楚了自己不必过多地使用finalize()。这个思想是正确的；它并不是进行普通清除工作的理想场所。那么，普通的清除工作应在何处进行呢？
+读完上述文字后，大家或许已弄清楚了自己不必过多地使用`finalize()`。这个思想是正确的；它并不是进行普通清除工作的理想场所。那么，普通的清除工作应在何处进行呢？
 
 4.3.2 必须执行清除
 
-为清除一个对象，那个对象的用户必须在希望进行清除的地点调用一个清除方法。这听起来似乎很容易做到，但却与C++“破坏器”的概念稍有抵触。在C++中，所有对象都会破坏（清除）。或者换句话说，所有对象都“应该”破坏。若将C++对象创建成一个本地对象，比如在堆栈中创建（在Java中是不可能的），那么清除或破坏工作就会在“结束花括号”所代表的、创建这个对象的作用域的末尾进行。若对象是用new创建的（类似于Java），那么当程序员调用C++的delete命令时（Java没有这个命令），就会调用相应的破坏器。若程序员忘记了，那么永远不会调用破坏器，我们最终得到的将是一个内存“漏洞”，另外还包括对象的其他部分永远不会得到清除。
+为清除一个对象，那个对象的用户必须在希望进行清除的地点调用一个清除方法。这听起来似乎很容易做到，但却与C++“破坏器”的概念稍有抵触。在C++中，所有对象都会破坏（清除）。或者换句话说，所有对象都“应该”破坏。若将C++对象创建成一个本地对象，比如在堆栈中创建（在Java中是不可能的），那么清除或破坏工作就会在“结束花括号”所代表的、创建这个对象的作用域的末尾进行。若对象是用`new`创建的（类似于Java），那么当程序员调用C++的`delete`命令时（Java没有这个命令），就会调用相应的破坏器。若程序员忘记了，那么永远不会调用破坏器，我们最终得到的将是一个内存“漏洞”，另外还包括对象的其他部分永远不会得到清除。
 
-相反，Java不允许我们创建本地（局部）对象——无论如何都要使用new。但在Java中，没有“delete”命令来释放对象，因为垃圾收集器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说正是由于存在垃圾收集机制，所以Java没有破坏器。然而，随着以后学习的深入，就会知道垃圾收集器的存在并不能完全消除对破坏器的需要，或者说不能消除对破坏器代表的那种机制的需要（而且绝对不能直接调用finalize()，所以应尽量避免用它）。若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然必须调用Java中的一个方法。它等价于C++的破坏器，只是没后者方便。
+相反，Java不允许我们创建本地（局部）对象——无论如何都要使用`new`。但在Java中，没有`delete`命令来释放对象，因为垃圾收集器会帮助我们自动释放存储空间。所以如果站在比较简化的立场，我们可以说正是由于存在垃圾收集机制，所以Java没有破坏器。然而，随着以后学习的深入，就会知道垃圾收集器的存在并不能完全消除对破坏器的需要，或者说不能消除对破坏器代表的那种机制的需要（而且绝对不能直接调用`finalize()`，所以应尽量避免用它）。若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然必须调用Java中的一个方法。它等价于C++的破坏器，只是没后者方便。
 
-finalize()最有用处的地方之一是观察垃圾收集的过程。下面这个例子向大家展示了垃圾收集所经历的过程，并对前面的陈述进行了总结。
+`finalize()`最有用处的地方之一是观察垃圾收集的过程。下面这个例子向大家展示了垃圾收集所经历的过程，并对前面的陈述进行了总结。
 
 ```
 //: Garbage.java
@@ -49,7 +49,7 @@ class Chair {
   int i;
   Chair() {
     i = ++created;
-    if(created == 47) 
+    if(created == 47)
       System.out.println("Created 47");
   }
   protected void finalize() {
@@ -101,11 +101,11 @@ public class Garbage {
 } ///:~
 ```
 
-上面这个程序创建了许多Chair对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建Chair。由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始运行。利用第二个标记f，Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的，它调用于垃圾收集期间。
+上面这个程序创建了许多`Chair`对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建`Chair`。由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为`gcrun`的标记来指出垃圾收集器是否已经开始运行。利用第二个标记`f`，`Chair`可告诉`main()`它应停止对象的生成。这两个标记都是在`finalize()`内部设置的，它调用于垃圾收集期间。
 
-另两个static变量——created以及finalized——分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后，每个Chair都有它自己的（非static）int i，所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后，标记会设为true，最终结束Chair对象的创建过程。
+另两个`static`变量——`created`以及`finalized`——分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后，每个`Chair`都有它自己的（非`static`）`int i`，所以能跟踪了解它具体的编号是多少。编号为47的`Chair`进行完收尾工作后，标记会设为`true`，最终结束`Chair`对象的创建过程。
 
-所有这些都在main()的内部进行——在下面这个循环里：
+所有这些都在`main()`的内部进行——在下面这个循环里：
 
 ```
 while(!Chair.f) {
@@ -114,15 +114,15 @@ new String("To take up space");
 }
 ```
 
-大家可能会疑惑这个循环什么时候会停下来，因为内部没有任何改变Chair.f值的语句。然而，finalize()进程会改变这个值，直至最终对编号47的对象进行收尾处理。
+大家可能会疑惑这个循环什么时候会停下来，因为内部没有任何改变`Chair.f`值的语句。然而，`finalize()`进程会改变这个值，直至最终对编号47的对象进行收尾处理。
 
-每次循环过程中创建的String对象只是属于额外的垃圾，用于吸引垃圾收集器——一旦垃圾收集器对可用内存的容量感到“紧张不安”，就会开始关注它。
+每次循环过程中创建的`String`对象只是属于额外的垃圾，用于吸引垃圾收集器——一旦垃圾收集器对可用内存的容量感到“紧张不安”，就会开始关注它。
 
-运行这个程序的时候，提供了一个命令行参数“before”或者“after”。其中，“before”参数会调用System.gc()方法（强制执行垃圾收集器），同时还会调用System.runFinalization()方法，以便进行收尾工作。这些方法都可在Java 1.0中使用，但通过使用“after”参数而调用的runFinalizersOnExit()方法却只有Java 1.1及后续版本提供了对它的支持（注释③）。注意可在程序执行的任何时候调用这个方法，而且收尾程序的执行与垃圾收集器是否运行是无关的。
+运行这个程序的时候，提供了一个命令行参数`before`或者`after`。其中，`before`参数会调用`System.gc()`方法（强制执行垃圾收集器），同时还会调用`System.runFinalization()`方法，以便进行收尾工作。这些方法都可在Java 1.0中使用，但通过使用`after`参数而调用的`runFinalizersOnExit()`方法却只有Java 1.1及后续版本提供了对它的支持（注释③）。注意可在程序执行的任何时候调用这个方法，而且收尾程序的执行与垃圾收集器是否运行是无关的。
 
-③：不幸的是，Java 1.0采用的垃圾收集器方案永远不能正确地调用finalize()。因此，finalize()方法（特别是那些用于关闭文件的）事实上经常都不会得到调用。现在有些文章声称所有收尾模块都会在程序退出的时候得到调用——即使到程序中止的时候，垃圾收集器仍未针对那些对象采取行动。这并不是真实的情况，所以我们根本不能指望finalize()能为所有对象而调用。特别地，finalize()在Java 1.0里几乎毫无用处。
+③：不幸的是，Java 1.0采用的垃圾收集器方案永远不能正确地调用`finalize()`。因此，`finalize()`方法（特别是那些用于关闭文件的）事实上经常都不会得到调用。现在有些文章声称所有收尾模块都会在程序退出的时候得到调用——即使到程序中止的时候，垃圾收集器仍未针对那些对象采取行动。这并不是真实的情况，所以我们根本不能指望`finalize()`能为所有对象而调用。特别地，`finalize()`在Java 1.0里几乎毫无用处。
 
-前面的程序向我们揭示出：在Java 1.1中，收尾模块肯定会运行这一许诺已成为现实——但前提是我们明确地强制它采取这一操作。若使用一个不是“before”或“after”的参数（如“none”），那么两个收尾工作都不会进行，而且我们会得到象下面这样的输出：
+前面的程序向我们揭示出：在Java 1.1中，收尾模块肯定会运行这一许诺已成为现实——但前提是我们明确地强制它采取这一操作。若使用一个不是`before`或`after`的参数（如`none`），那么两个收尾工作都不会进行，而且我们会得到象下面这样的输出：
 
 ```
 Created 47
@@ -135,7 +135,7 @@ total created = 9834, total finalized = 108
 bye!
 ```
 
-因此，到程序结束的时候，并非所有收尾模块都会得到调用（注释④）。为强制进行收尾工作，可先调用System.gc()，再调用System.runFinalization()。这样可清除到目前为止没有使用的所有对象。这样做一个稍显奇怪的地方是在调用runFinalization()之前调用gc()，这看起来似乎与Sun公司的文档说明有些抵触，它宣称首先运行收尾模块，再释放存储空间。然而，若在这里首先调用runFinalization()，再调用gc()，收尾模块根本不会执行。
+因此，到程序结束的时候，并非所有收尾模块都会得到调用（注释④）。为强制进行收尾工作，可先调用`System.gc()`，再调用`System.runFinalization()`。这样可清除到目前为止没有使用的所有对象。这样做一个稍显奇怪的地方是在调用`runFinalization()`之前调用`gc()`，这看起来似乎与Sun公司的文档说明有些抵触，它宣称首先运行收尾模块，再释放存储空间。然而，若在这里首先调用`runFinalization()`，再调用`gc()`，收尾模块根本不会执行。
 
 ④：到你读到本书时，有些Java虚拟机（JVM）可能已开始表现出不同的行为。