ch17

15.1 机器的标识.md

@@ -50,11 +50,11 @@ Colossus/202.98.41.151
 
 15.1.1 服务器和客户端
 
-网络最基本的精神就是让两台机器连接到一起，并相互“交谈”或者“沟通”。一旦两台机器都发现了对方，就可以展开一次令人愉快的双向对话。但它们怎样才能“发现”对方呢？这就象在游乐园里那样：一台机器不得不停留在一个地方，侦听其他机器说：“嘿，你在哪里呢？”
+网络最基本的精神就是让两台机器连接到一起，并相互“交谈”或者“沟通”。一旦两台机器都发现了对方，就可以展开一次令人愉快的双向对话。但它们怎样才能“发现”对方呢？这就象在游乐园里那样：一台机器不得不停留在一个地方，监听其他机器说：“嘿，你在哪里呢？”
 
 “停留在一个地方”的机器叫作“服务器”（Server）；到处“找人”的机器则叫作“客户端”（Client）或者“客户”。它们之间的区别只有在客户端试图同服务器连接的时候才显得非常明显。一旦连通，就变成了一种双向通信，谁来扮演服务器或者客户端便显得不那么重要了。
 
-所以服务器的主要任务是侦听建立连接的请求，这是由我们创建的特定服务器对象完成的。而客户端的任务是试着与一台服务器建立连接，这是由我们创建的特定客户端对象完成的。一旦连接建好，那么无论在服务器端还是客户端端，连接只是魔术般地变成了一个IO数据流对象。从这时开始，我们可以象读写一个普通的文件那样对待连接。所以一旦建好连接，我们只需象第10章那样使用自己熟悉的IO命令即可。这正是Java连网最方便的一个地方。
+所以服务器的主要任务是监听建立连接的请求，这是由我们创建的特定服务器对象完成的。而客户端的任务是试着与一台服务器建立连接，这是由我们创建的特定客户端对象完成的。一旦连接建好，那么无论在服务器端还是客户端端，连接只是魔术般地变成了一个IO数据流对象。从这时开始，我们可以象读写一个普通的文件那样对待连接。所以一旦建好连接，我们只需象第10章那样使用自己熟悉的IO命令即可。这正是Java连网最方便的一个地方。
 
 1. 在没有网络的前提下测试程序
 

15.2 套接字.md

@@ -2,11 +2,11 @@
 
 “套接字”或者“插座”（`Socket`）也是一种软件形式的抽象，用于表达两台机器间一个连接的“终端”。针对一个特定的连接，每台机器上都有一个“套接字”，可以想象它们之间有一条虚拟的“线缆”。线缆的每一端都插入一个“套接字”或者“插座”里。当然，机器之间的物理性硬件以及电缆连接都是完全未知的。抽象的基本宗旨是让我们尽可能不必知道那些细节。
 
-在Java中，我们创建一个套接字，用它建立与其他机器的连接。从套接字得到的结果是一个`InputStream`以及`OutputStream`（若使用恰当的转换器，则分别是`Reader`和`Writer`），以便将连接作为一个IO流对象对待。有两个基于数据流的套接字类：`ServerSocket`，服务器用它“侦听”进入的连接；以及`Socket`，客户用它初始一次连接。一旦客户（程序）申请建立一个套接字连接，`ServerSocket`就会返回（通过`accept()`方法）一个对应的服务器端套接字，以便进行直接通信。从此时起，我们就得到了真正的“套接字－套接字”连接，可以用同样的方式对待连接的两端，因为它们本来就是相同的！此时可以利用`getInputStream()`以及`getOutputStream()`从每个套接字产生对应的`InputStream`和`OutputStream`对象。这些数据流必须封装到缓冲区内。可按第10章介绍的方法对类进行格式化，就象对待其他任何流对象那样。
+在Java中，我们创建一个套接字，用它建立与其他机器的连接。从套接字得到的结果是一个`InputStream`以及`OutputStream`（若使用恰当的转换器，则分别是`Reader`和`Writer`），以便将连接作为一个IO流对象对待。有两个基于数据流的套接字类：`ServerSocket`，服务器用它“监听”进入的连接；以及`Socket`，客户用它初始一次连接。一旦客户（程序）申请建立一个套接字连接，`ServerSocket`就会返回（通过`accept()`方法）一个对应的服务器端套接字，以便进行直接通信。从此时起，我们就得到了真正的“套接字－套接字”连接，可以用同样的方式对待连接的两端，因为它们本来就是相同的！此时可以利用`getInputStream()`以及`getOutputStream()`从每个套接字产生对应的`InputStream`和`OutputStream`对象。这些数据流必须封装到缓冲区内。可按第10章介绍的方法对类进行格式化，就象对待其他任何流对象那样。
 
 对于Java库的命名机制，`ServerSocket`（服务器套接字）的使用无疑是容易产生混淆的又一个例证。大家可能认为`ServerSocket`最好叫作`ServerConnector`（服务器连接器），或者其他什么名字，只是不要在其中安插一个`Socket`。也可能以为`ServerSocket`和`Socket`都应从一些通用的基类继承。事实上，这两种类确实包含了几个通用的方法，但还不够资格把它们赋给一个通用的基类。相反，`ServerSocket`的主要任务是在那里耐心地等候其他机器同它连接，再返回一个实际的`Socket`。这正是`ServerSocket`这个命名不恰当的地方，因为它的目标不是真的成为一个`Socket`，而是在其他人同它连接的时候产生一个`Socket`对象。
 
-然而，`ServerSocket`确实会在主机上创建一个物理性的“服务器”或者侦听用的套接字。这个套接字会侦听进入的连接，然后利用`accept()`方法返回一个“已建立”套接字（本地和远程端点均已定义）。容易混淆的地方是这两个套接字（侦听和已建立）都与相同的服务器套接字关联在一起。侦听套接字只能接收新的连接请求，不能接收实际的数据包。所以尽管`ServerSocket`对于编程并无太大的意义，但它确实是“物理性”的。
+然而，`ServerSocket`确实会在主机上创建一个物理性的“服务器”或者监听用的套接字。这个套接字会监听进入的连接，然后利用`accept()`方法返回一个“已建立”套接字（本地和远程端点均已定义）。容易混淆的地方是这两个套接字（监听和已建立）都与相同的服务器套接字关联在一起。监听套接字只能接收新的连接请求，不能接收实际的数据包。所以尽管`ServerSocket`对于编程并无太大的意义，但它确实是“物理性”的。
 
 创建一个`ServerSocket`时，只需为其赋予一个端口编号。不必把一个IP地址分配它，因为它已经在自己代表的那台机器上了。但在创建一个`Socket`时，却必须同时赋予IP地址以及要连接的端口编号（另一方面，从`ServerSocket.accept()`返回的`Socket`已经包含了所有这些信息）。
 

15.5 一个Web应用.md

@@ -13,7 +13,7 @@
 
 现在讨论一下服务器应用（程序）的问题，我把它叫作`NameCollecor`（名字收集器）。假如多名用户同时尝试提交他们的E-mail地址，那么会发生什么情况呢？若`NameCollector`使用TCP/IP套接字，那么必须运用早先介绍的多线程机制来实现对多个客户的并发控制。但所有这些线程都试图把数据写到同一个文件里，其中保存了所有E-mail地址。这便要求我们设立一种锁定机制，保证多个线程不会同时访问那个文件。一个“信号机”可在这里帮助我们达到目的，但或许还有一种更简单的方式。
 
-如果我们换用数据报，就不必使用多线程了。用单个数据报即可“侦听”进入的所有数据报。一旦监视到有进入的消息，程序就会进行适当的处理，并将答复数据作为一个数据报传回原先发出请求的那名接收者。若数据报半路上丢失了，则用户会注意到没有答复数据传回，所以可以重新提交请求。
+如果我们换用数据报，就不必使用多线程了。用单个数据报即可“监听”进入的所有数据报。一旦监视到有进入的消息，程序就会进行适当的处理，并将答复数据作为一个数据报传回原先发出请求的那名接收者。若数据报半路上丢失了，则用户会注意到没有答复数据传回，所以可以重新提交请求。
 
 服务器应用收到一个数据报，并对它进行解读的时候，必须提取出其中的电子函件地址，并检查本机保存的数据文件，看看里面是否已经包含了那个地址（如果没有，则添加之）。所以我们现在遇到了一个新的问题。Java 1.0似乎没有足够的能力来方便地处理包含了电子函件地址的文件（Java 1.1则不然）。但是，用C轻易就可以解决这个问题。因此，我们在这儿有机会学习将一个非Java程序同Java程序连接的最简便方式。程序使用的`Runtime`对象包含了一个名为`exec()`的方法，它会独立机器上一个独立的程序，并返回一个`Process`（进程）对象。我们可以取得一个`OutputStream`，它同这个单独程序的标准输入连接在一起；并取得一个`InputStream`，它则同标准输出连接到一起。要做的全部事情就是用任何语言写一个程序，只要它能从标准输入中取得自己的输入数据，并将输出结果写入标准输出即可。如果有些问题不能用Java简便与快速地解决（或者想利用原有代码，不想改写），就可以考虑采用这种方法。亦可使用Java的“固有方法”（Native Method），但那要求更多的技巧，大家可以参考一下附录A。
 
@@ -84,7 +84,7 @@ int main() {
 
 2. Java程序
 
-这个程序先启动上述的C程序，再建立必要的连接，以便同它“交谈”。随后，它创建一个数据报套接字，用它“监视”或者“侦听”来自程序片的数据报包。
+这个程序先启动上述的C程序，再建立必要的连接，以便同它“交谈”。随后，它创建一个数据报套接字，用它“监视”或者“监听”来自程序片的数据报包。
 
 ```
 //: NameCollector.java
@@ -325,7 +325,7 @@ public class NameSender extends Applet
 
 程序片的UI（用户界面）非常简单。它包含了一个`TestField`（文本字段），以便我们键入一个电子函件地址；以及一个`Button`（按钮），用于将地址发给服务器。两个`Label`（标签）用于向用户报告状态信息。
 
-到现在为止，大家已能判断出`DatagramSocket`、`InetAddress`、缓冲区以及`DatagramPacket`都属于网络连接中比较麻烦的部分。最后，大家可看到`run()`方法实现了线程部分，使程序片能够“侦听”由服务器传回的响应信息。
+到现在为止，大家已能判断出`DatagramSocket`、`InetAddress`、缓冲区以及`DatagramPacket`都属于网络连接中比较麻烦的部分。最后，大家可看到`run()`方法实现了线程部分，使程序片能够“监听”由服务器传回的响应信息。
 
 `init()`方法用大家熟悉的布局工具设置GUI，然后创建`DatagramSocket`，它将同时用于数据报的收发。
 

17.1 文字处理.md

 # 17.1 文字处理
 
 
-如果您有C或C++的经验，那么最开始可能会对Java控制文本的能力感到怀疑。事实上，我们最害怕的就是速度特别慢，这可能妨碍我们创造能力的发挥。然而，Java对应的工具（特别是String类）具有很强的功能，就象本节的例子展示的那样（而且性能也有一定程度的提升）。
+如果您有C或C++的经验，那么最开始可能会对Java控制文本的能力感到怀疑。事实上，我们最害怕的就是速度特别慢，这可能妨碍我们创造能力的发挥。然而，Java对应的工具（特别是`String`类）具有很强的功能，就象本节的例子展示的那样（而且性能也有一定程度的提升）。
 
 正如大家即将看到的那样，建立这些例子的目的都是为了解决本书编制过程中遇到的一些问题。但是，它们的能力并非仅止于此。通过简单的改造，即可让它们在其他场合大显身手。除此以外，它们还揭示出了本书以前没有强调过的一项Java特性。
 
 17.1.1 提取代码列表
 
-对于本书每一个完整的代码列表（不是代码段），大家无疑会注意到它们都用特殊的注释记号起始与结束（'//:'和'///:~'）。之所以要包括这种标志信息，是为了能将代码从本书自动提取到兼容的源码文件中。在我的前一本书里，我设计了一个系统，可将测试过的代码文件自动合并到书中。但对于这本书，我发现一种更简便的做法是一旦通过了最初的测试，就把代码粘贴到书中。而且由于很难第一次就编译通过，所以我在书的内部编辑代码。但如何提取并测试代码呢？这个程序就是关键。如果你打算解决一个文字处理的问题，那么它也很有利用价值。该例也演示了String类的许多特性。
+对于本书每一个完整的代码列表（不是代码段），大家无疑会注意到它们都用特殊的注释记号起始与结束（`//:`和`///:~`）。之所以要包括这种标志信息，是为了能将代码从本书自动提取到兼容的源码文件中。在我的前一本书里，我设计了一个系统，可将测试过的代码文件自动合并到书中。但对于这本书，我发现一种更简便的做法是一旦通过了最初的测试，就把代码粘贴到书中。而且由于很难第一次就编译通过，所以我在书的内部编辑代码。但如何提取并测试代码呢？这个程序就是关键。如果你打算解决一个文字处理的问题，那么它也很有利用价值。该例也演示了`String`类的许多特性。
 
-我首先将整本书都以ASCII文本格式保存成一个独立的文件。CodePackager程序有两种运行模式（在usageString有相应的描述）：如果使用-p标志，程序就会检查一个包含了ASCII文本（即本书的内容）的一个输入文件。它会遍历这个文件，按照注释记号提取出代码，并用位于第一行的文件名来决定创建文件使用什么名字。除此以外，在需要将文件置入一个特殊目录的时候，它还会检查package语句（根据由package语句指定的路径选择）。
+我首先将整本书都以ASCII文本格式保存成一个独立的文件。`CodePackager`程序有两种运行模式（在`usageString`有相应的描述）：如果使用`-p`标志，程序就会检查一个包含了ASCII文本（即本书的内容）的一个输入文件。它会遍历这个文件，按照注释记号提取出代码，并用位于第一行的文件名来决定创建文件使用什么名字。除此以外，在需要将文件置入一个特殊目录的时候，它还会检查`package`语句（根据由`package`语句指定的路径选择）。
 
-但这样还不够。程序还要对包（package）名进行跟踪，从而监视章内发生的变化。由于每一章使用的所有包都以c02，c03，c04等等起头，用于标记它们所属的是哪一章（除那些以com起头的以外，它们在对不同的章进行跟踪的时候会被忽略）——只要每一章的第一个代码列表包含了一个package，所以CodePackager程序能知道每一章发生的变化，并将后续的文件放到新的子目录里。
-每个文件提取出来时，都会置入一个SourceCodeFile对象，随后再将那个对象置入一个集合（后面还会详尽讲述这个过程）。这些SourceCodeFile对象可以简单地保存在文件中，那正是本项目的第二个用途。如果直接调用CodePackager，不添加-p标志，它就会将一个“打包”文件作为输入。那个文件随后会被提取（释放）进入单独的文件。所以-p标志的意思就是提取出来的文件已被“打包”（packed）进入这个单一的文件。
+但这样还不够。程序还要对包（`package`）名进行跟踪，从而监视章内发生的变化。由于每一章使用的所有包都以`c02`，`c03`，`c04`等等起头，用于标记它们所属的是哪一章（除那些以`com`起头的以外，它们在对不同的章进行跟踪的时候会被忽略）——只要每一章的第一个代码列表包含了一个`package`，所以`CodePackager`程序能知道每一章发生的变化，并将后续的文件放到新的子目录里。
+每个文件提取出来时，都会置入一个`SourceCodeFile`对象，随后再将那个对象置入一个集合（后面还会详尽讲述这个过程）。这些`SourceCodeFile`对象可以简单地保存在文件中，那正是本项目的第二个用途。如果直接调用`CodePackager`，不添加`-p`标志，它就会将一个“打包”文件作为输入。那个文件随后会被提取（释放）进入单独的文件。所以`-p`标志的意思就是提取出来的文件已被“打包”（`packed`）进入这个单一的文件。
 
-但为什么还要如此麻烦地使用打包文件呢？这是由于不同的计算机平台用不同的方式在文件里保存文本信息。其中最大的问题是换行字符的表示方法；当然，还有可能存在另一些问题。然而，Java有一种特殊类型的IO数据流——DataOutputStream——它可以保证“无论数据来自何种机器，只要使用一个DataInputStream收取这些数据，就可用本机正确的格式保存它们”。也就是说，Java负责控制与不同平台有关的所有细节，而这正是Java最具魅力的一点。所以-p标志能将所有东西都保存到单一的文件里，并采用通用的格式。用户可从Web下载这个文件以及Java程序，然后对这个文件运行CodePackager，同时不指定-p标志，文件便会释放到系统中正确的场所（亦可指定另一个子目录；否则就在当前目录创建子目录）。为确保不会留下与特定平台有关的格式，凡是需要描述一个文件或路径的时候，我们就使用File对象。除此以外，还有一项特别的安全措施：在每个子目录里都放入一个空文件；那个文件的名字指出在那个子目录里应找到多少个文件。
+但为什么还要如此麻烦地使用打包文件呢？这是由于不同的计算机平台用不同的方式在文件里保存文本信息。其中最大的问题是换行字符的表示方法；当然，还有可能存在另一些问题。然而，Java有一种特殊类型的IO数据流——`DataOutputStream`——它可以保证“无论数据来自何种机器，只要使用一个`DataInputStream`收取这些数据，就可用本机正确的格式保存它们”。也就是说，Java负责控制与不同平台有关的所有细节，而这正是Java最具魅力的一点。所以`-p`标志能将所有东西都保存到单一的文件里，并采用通用的格式。用户可从Web下载这个文件以及Java程序，然后对这个文件运行`CodePackager`，同时不指定`-p`标志，文件便会释放到系统中正确的场所（亦可指定另一个子目录；否则就在当前目录创建子目录）。为确保不会留下与特定平台有关的格式，凡是需要描述一个文件或路径的时候，我们就使用File对象。除此以外，还有一项特别的安全措施：在每个子目录里都放入一个空文件；那个文件的名字指出在那个子目录里应找到多少个文件。
 
 下面是完整的代码，后面会对它进行详细的说明：
 
 ```
 //: CodePackager.java
-// "Packs" and "unpacks" the code in "Thinking 
+// "Packs" and "unpacks" the code in "Thinking
 // in Java" for cross-platform distribution.
 /* Commented so CodePackager sees it and starts
-   a new chapter directory, but so you don't 
+   a new chapter directory, but so you don't
    have to worry about the directory where this
    program lives:
 package c17;
@@ -104,7 +104,7 @@ class IO {
 }
 
 class SourceCodeFile {
-  public static final String 
+  public static final String
     startMarker = "//:", // Start of source file
     endMarker = "} ///:~", // End of source
     endMarker2 = "}; ///:~", // C++ file end
@@ -138,7 +138,7 @@ class SourceCodeFile {
     return dirname + filesep + filename;
   }
   // Constructor for parsing from document file:
-  public SourceCodeFile(String firstLine, 
+  public SourceCodeFile(String firstLine,
       BufferedReader in) {
     dirname = chapter;
     // Skip past marker:
@@ -159,7 +159,7 @@ class SourceCodeFile {
         if(s.startsWith(startMarker))
           Pr.error("No end of file marker for " +
             filename);
-        // For this program, no spaces before 
+        // For this program, no spaces before
         // the "package" keyword are allowed
         // in the input source code:
         else if(s.startsWith("package")) {
@@ -173,7 +173,7 @@ class SourceCodeFile {
           if(!pdir.startsWith("com")) {
             int firstDot = pdir.indexOf('.');
             if(firstDot != -1)
-              chapter = 
+              chapter =
                 pdir.substring(0,firstDot);
             else
               chapter = pdir;
@@ -223,7 +223,7 @@ class SourceCodeFile {
         oldsep.charAt(0), filesep.charAt(0));
       filename = filename.replace(
         oldsep.charAt(0), filesep.charAt(0));
-      System.out.println("listing: " + dirname 
+      System.out.println("listing: " + dirname
         + filesep + filename);
       while((s = pFile.readLine()) != null) {
         // Watch for end of code listing:
@@ -238,8 +238,8 @@ class SourceCodeFile {
       System.err.println("Error reading line");
     }
   }
-  public boolean hasFile() { 
-    return filename != null; 
+  public boolean hasFile() {
+    return filename != null;
   }
   public String directory() { return dirname; }
   public String filename() { return filename; }
@@ -248,11 +248,11 @@ class SourceCodeFile {
   public void writePacked(DataOutputStream out) {
     try {
       out.writeBytes(
-        packMarker + dirname + "#" 
+        packMarker + dirname + "#"
         + filename + eol);
       out.writeBytes(contents);
     } catch(IOException e) {
-      Pr.error("writing " + dirname + 
+      Pr.error("writing " + dirname +
         filesep + filename);
     }
   }
@@ -297,7 +297,7 @@ class DirMap {
         "Writing directory " + dir);
       Vector v = (Vector)t.get(dir);
       for(int i = 0; i < v.size(); i++) {
-        SourceCodeFile f = 
+        SourceCodeFile f =
           (SourceCodeFile)v.elementAt(i);
         f.writePacked(packed);
       }
@@ -311,7 +311,7 @@ class DirMap {
       String dir = (String)e.nextElement();
       Vector v = (Vector)t.get(dir);
       for(int i = 0; i < v.size(); i++) {
-        SourceCodeFile f = 
+        SourceCodeFile f =
           (SourceCodeFile)v.elementAt(i);
         f.writeFile(rootpath);
       }
@@ -352,15 +352,15 @@ public class CodePackager {
       extractPackedFile(args);
     }
   }
-  private static String currentLine; 
+  private static String currentLine;
   private static BufferedReader in;
   private static DirMap dm;
-  private static void 
+  private static void
   createPackedFile(String[] args) {
     dm = new DirMap();
     in = IO.disOpen(args[1]);
     try {
-      while((currentLine = in.readLine()) 
+      while((currentLine = in.readLine())
           != null) {
         if(currentLine.startsWith(
             SourceCodeFile.startMarker)) {
@@ -378,7 +378,7 @@ public class CodePackager {
     IO.close(in);
     dm.writePackedFile(args[2]);
   }
-  private static void 
+  private static void
   extractPackedFile(String[] args) {
     if(args.length == 2) // Alternate directory
       dm = new DirMap(args[1]);
@@ -410,11 +410,11 @@ public class CodePackager {
 } ///:~
 ```
 
-我们注意到package语句已经作为注释标志出来了。由于这是本章的第一个程序，所以package语句是必需的，用它告诉CodePackager已改换到另一章。但是把它放入包里却会成为一个问题。当我们创建一个包的时候，需要将结果程序同一个特定的目录结构联系在一起，这一做法对本书的大多数例子都是适用的。但在这里，CodePackager程序必须在一个专用的目录里编译和运行，所以package语句作为注释标记出去。但对CodePackager来说，它“看起来”依然象一个普通的package语句，因为程序还不是特别复杂，不能侦查到多行注释（没有必要做得这么复杂，这里只要求方便就行）。
+我们注意到`package`语句已经作为注释标志出来了。由于这是本章的第一个程序，所以`package`语句是必需的，用它告诉`CodePackager`已改换到另一章。但是把它放入包里却会成为一个问题。当我们创建一个包的时候，需要将结果程序同一个特定的目录结构联系在一起，这一做法对本书的大多数例子都是适用的。但在这里，`CodePackager`程序必须在一个专用的目录里编译和运行，所以`package`语句作为注释标记出去。但对`CodePackager`来说，它“看起来”依然象一个普通的`package`语句，因为程序还不是特别复杂，不能侦查到多行注释（没有必要做得这么复杂，这里只要求方便就行）。
 
-头两个类是“支持／工具”类，作用是使程序剩余的部分在编写时更加连贯，也更便于阅读。第一个是Pr，它类似ANSI C的perror库，两者都能打印出一条错误提示消息（但同时也会退出程序）。第二个类将文件的创建过程封装在内，这个过程已在第10章介绍过了；大家已经知道，这样做很快就会变得非常累赘和麻烦。为解决这个问题，第10章提供的方案致力于新类的创建，但这儿的“静态”方法已经使用过了。在那些方法中，正常的异常会被捕获，并相应地进行处理。这些方法使剩余的代码显得更加清爽，更易阅读。
+头两个类是“支持／工具”类，作用是使程序剩余的部分在编写时更加连贯，也更便于阅读。第一个是`Pr`，它类似ANSI C的`perror`库，两者都能打印出一条错误提示消息（但同时也会退出程序）。第二个类将文件的创建过程封装在内，这个过程已在第10章介绍过了；大家已经知道，这样做很快就会变得非常累赘和麻烦。为解决这个问题，第10章提供的方案致力于新类的创建，但这儿的“静态”方法已经使用过了。在那些方法中，正常的异常会被捕获，并相应地进行处理。这些方法使剩余的代码显得更加清爽，更易阅读。
 
-帮助解决问题的第一个类是SourceCodeFile（源码文件），它代表本书一个源码文件包含的所有信息（内容、文件名以及目录）。它同时还包含了一系列String常数，分别代表一个文件的开始与结束；在打包文件内使用的一个标记；当前系统的换行符；文件路径分隔符（注意要用System.getProperty()侦查本地版本是什么）；以及一大段版权声明，它是从下面这个Copyright.txt文件里提取出来的：
+帮助解决问题的第一个类是`SourceCodeFile`（源码文件），它代表本书一个源码文件包含的所有信息（内容、文件名以及目录）。它同时还包含了一系列`String`常数，分别代表一个文件的开始与结束；在打包文件内使用的一个标记；当前系统的换行符；文件路径分隔符（注意要用`System.getProperty()`侦查本地版本是什么）；以及一大段版权声明，它是从下面这个`Copyright.txt`文件里提取出来的：
 
 ```
 //////////////////////////////////////////////////
@@ -427,10 +427,10 @@ public class CodePackager {
 // executable form only. Permission is granted to use
 // this file in classroom situations, including its
 // use in presentation materials, as long as the book
-// "Thinking in Java" is cited as the source. 
+// "Thinking in Java" is cited as the source.
 // Except in classroom situations, you may not copy
 // and distribute this code; instead, the sole
-// distribution point is http://www.BruceEckel.com 
+// distribution point is http://www.BruceEckel.com
 // (and official mirror sites) where it is
 // freely available. You may not remove this
 // copyright and notice. You may not distribute
@@ -467,66 +467,66 @@ public class CodePackager {
 
 从一个打包文件中提取文件时，当初所用系统的文件分隔符也会标注出来，以便用本地系统适用的符号替换它。
 
-当前章的子目录保存在chapter字段中，它初始化成c02（大家可注意一下第2章的列表正好没有包含一个打包语句）。只有在当前文件里发现一个package（打包）语句时，chapter字段才会发生改变。
+当前章的子目录保存在`chapter`字段中，它初始化成`c02`（大家可注意一下第2章的列表正好没有包含一个打包语句）。只有在当前文件里发现一个`package`（打包）语句时，`chapter`字段才会发生改变。
 
 1. 构建一个打包文件
 
-第一个构造器用于从本书的ASCII文本版里提取出一个文件。发出调用的代码（在列表里较深的地方）会读入并检查每一行，直到找到与一个列表的开头相符的为止。在这个时候，它就会新建一个SourceCodeFile对象，将第一行的内容（已经由调用代码读入了）传递给它，同时还要传递BufferedReader对象，以便在这个缓冲区中提取源码列表剩余的内容。
+第一个构造器用于从本书的ASCII文本版里提取出一个文件。发出调用的代码（在列表里较深的地方）会读入并检查每一行，直到找到与一个列表的开头相符的为止。在这个时候，它就会新建一个`SourceCodeFile`对象，将第一行的内容（已经由调用代码读入了）传递给它，同时还要传递`BufferedReader`对象，以便在这个缓冲区中提取源码列表剩余的内容。
 
-从这时起，大家会发现String方法被频繁运用。为提取出文件名，需调用substring()的重载版本，令其从一个起始偏移开始，一直读到字符串的末尾，从而形成一个“子串”。为算出这个起始索引，先要用length()得出startMarker的总长，再用trim()删除字符串头尾多余的空格。第一行在文件名后也可能有一些字符；它们是用indexOf()侦测出来的。若没有发现找到我们想寻找的字符，就返回-1；若找到那些字符，就返回它们第一次出现的位置。注意这也是indexOf()的一个重载版本，采用一个字符串作为参数，而非一个字符。
+从这时起，大家会发现`String`方法被频繁运用。为提取出文件名，需调用`substring()`的重载版本，令其从一个起始偏移开始，一直读到字符串的末尾，从而形成一个“子串”。为算出这个起始索引，先要用`length()`得出`startMarker`的总长，再用`trim()`删除字符串头尾多余的空格。第一行在文件名后也可能有一些字符；它们是用`indexOf()`侦测出来的。若没有发现找到我们想寻找的字符，就返回-1；若找到那些字符，就返回它们第一次出现的位置。注意这也是`indexOf()`的一个重载版本，采用一个字符串作为参数，而非一个字符。
 
-解析出并保存好文件名后，第一行会被置入字符串contents中（该字符串用于保存源码清单的完整正文）。随后，将剩余的代码行读入，并合并进入contents字符串。当然事情并没有想象的那么简单，因为特定的情况需加以特别的控制。一种情况是错误检查：若直接遇到一个startMarker（起始标记），表明当前操作的这个代码列表没有设置一个结束标记。这属于一个出错条件，需要退出程序。
+解析出并保存好文件名后，第一行会被置入字符串`contents`中（该字符串用于保存源码清单的完整正文）。随后，将剩余的代码行读入，并合并进入`contents`字符串。当然事情并没有想象的那么简单，因为特定的情况需加以特别的控制。一种情况是错误检查：若直接遇到一个`startMarker`（起始标记），表明当前操作的这个代码列表没有设置一个结束标记。这属于一个出错条件，需要退出程序。
 
-另一种特殊情况与package关键字有关。尽管Java是一种自由形式的语言，但这个程序要求package关键字必须位于行首。若发现package关键字，就通过检查位于开头的空格以及位于末尾的分号，从而提取出包名（注意亦可一次单独的操作实现，方法是使用重载的substring()，令其同时检查起始和结束索引位置）。随后，将包名中的点号替换成特定的文件分隔符——当然，这里要假设文件分隔符仅有一个字符的长度。尽管这个假设可能对目前的所有系统都是适用的，但一旦遇到问题，一定不要忘了检查一下这里。
-默认操作是将每一行都连接到contents里，同时还有换行字符，直到遇到一个endMarker（结束标记）为止。该标记指出构造器应当停止了。若在endMarker之前遇到了文件结尾，就认为存在一个错误。
+另一种特殊情况与`package`关键字有关。尽管Java是一种自由形式的语言，但这个程序要求`package`关键字必须位于行首。若发现`package`关键字，就通过检查位于开头的空格以及位于末尾的分号，从而提取出包名（注意亦可一次单独的操作实现，方法是使用重载的`substring()`，令其同时检查起始和结束索引位置）。随后，将包名中的点号替换成特定的文件分隔符——当然，这里要假设文件分隔符仅有一个字符的长度。尽管这个假设可能对目前的所有系统都是适用的，但一旦遇到问题，一定不要忘了检查一下这里。
+默认操作是将每一行都连接到`contents`里，同时还有换行字符，直到遇到一个`endMarker`（结束标记）为止。该标记指出构造器应当停止了。若在`endMarker`之前遇到了文件结尾，就认为存在一个错误。
 
 2. 从打包文件中提取
 
-第二个构造器用于将源码文件从打包文件中恢复（提取）出来。在这儿，作为调用者的方法不必担心会跳过一些中间文本。打包文件包含了所有源码文件，它们相互间紧密地靠在一起。需要传递给该构造器的仅仅是一个BufferedReader，它代表着“信息源”。构造器会从中提取出自己需要的信息。但在每个代码列表开始的地方还有一些配置信息，它们的身份是用packMarker（打包标记）指出的。若packMarker不存在，意味着调用者试图用错误的方法来使用这个构造器。
+第二个构造器用于将源码文件从打包文件中恢复（提取）出来。在这儿，作为调用者的方法不必担心会跳过一些中间文本。打包文件包含了所有源码文件，它们相互间紧密地靠在一起。需要传递给该构造器的仅仅是一个`BufferedReader`，它代表着“信息源”。构造器会从中提取出自己需要的信息。但在每个代码列表开始的地方还有一些配置信息，它们的身份是用`packMarker`（打包标记）指出的。若`packMarker`不存在，意味着调用者试图用错误的方法来使用这个构造器。
 
-一旦发现packMarker，就会将其剥离出来，并提取出目录名（用一个'#'结尾）以及文件名（直到行末）。不管在哪种情况下，旧分隔符都会被替换成本地适用的一个分隔符，这是用String replace()方法实现的。老的分隔符被置于打包文件的开头，在代码列表稍靠后的一部分即可看到是如何把它提取出来的。
+一旦发现`packMarker`，就会将其剥离出来，并提取出目录名（用一个`#`结尾）以及文件名（直到行末）。不管在哪种情况下，旧分隔符都会被替换成本地适用的一个分隔符，这是用`String replace()`方法实现的。老的分隔符被置于打包文件的开头，在代码列表稍靠后的一部分即可看到是如何把它提取出来的。
 
-构造器剩下的部分就非常简单了。它读入每一行，把它合并到contents里，直到遇见endMarker为止。
+构造器剩下的部分就非常简单了。它读入每一行，把它合并到`contents`里，直到遇见`endMarker`为止。
 
 3. 程序列表的存取
 
-接下来的一系列方法是简单的访问器：directory()、filename()（注意方法可能与字段有相同的拼写和大小写形式）和contents()。而hasFile()用于指出这个对象是否包含了一个文件（很快就会知道为什么需要这个）。
+接下来的一系列方法是简单的访问器：`directory()`、`filename()`（注意方法可能与字段有相同的拼写和大小写形式）和`contents()`。而`hasFile()`用于指出这个对象是否包含了一个文件（很快就会知道为什么需要这个）。
 
-最后三个方法致力于将这个代码列表写进一个文件——要么通过writePacked()写入一个打包文件，要么通过writeFile()写入一个Java源码文件。writePacked()需要的唯一东西就是DataOutputStream，它是在别的地方打开的，代表着准备写入的文件。它先把头信息置入第一行，再调用writeBytes()将contents（内容）写成一种“通用”格式。
+最后三个方法致力于将这个代码列表写进一个文件——要么通过`writePacked()`写入一个打包文件，要么通过`writeFile()`写入一个Java源码文件。`writePacked()`需要的唯一东西就是`DataOutputStream`，它是在别的地方打开的，代表着准备写入的文件。它先把头信息置入第一行，再调用`writeBytes()`将`contents`（内容）写成一种“通用”格式。
 
-准备写Java源码文件时，必须先把文件建好。这是用IO.psOpen()实现的。我们需要向它传递一个File对象，其中不仅包含了文件名，也包含了路径信息。但现在的问题是：这个路径实际存在吗？用户可能决定将所有源码目录都置入一个完全不同的子目录，那个目录可能是尚不存在的。所以在正式写每个文件之前，都要调用File.mkdirs()方法，建好我们想向其中写入文件的目录路径。它可一次性建好整个路径。
+准备写Java源码文件时，必须先把文件建好。这是用`IO.psOpen()`实现的。我们需要向它传递一个`File`对象，其中不仅包含了文件名，也包含了路径信息。但现在的问题是：这个路径实际存在吗？用户可能决定将所有源码目录都置入一个完全不同的子目录，那个目录可能是尚不存在的。所以在正式写每个文件之前，都要调用`File.mkdirs()`方法，建好我们想向其中写入文件的目录路径。它可一次性建好整个路径。
 
 4. 整套列表的包容
 
 以子目录的形式组织代码列表是非常方便的，尽管这要求先在内存中建好整套列表。之所以要这样做，还有另一个很有说服力的原因：为了构建更“健康”的系统。也就是说，在创建代码列表的每个子目录时，都会加入一个额外的文件，它的名字包含了那个目录内应有的文件数目。
 
-DirMap类可帮助我们实现这一效果，并有效地演示了一个“多重映射”的概述。这是通过一个散列表（Hashtable）实现的，它的“键”是准备创建的子目录，而“值”是包含了那个特定目录中的SourceCodeFile对象的Vector对象。所以，我们在这儿并不是将一个“键”映射（或对应）到一个值，而是通过对应的Vector，将一个键“多重映射”到一系列值。尽管这听起来似乎很复杂，但具体实现时却是非常简单和直接的。大家可以看到，DirMap类的大多数代码都与向文件中的写入有关，而非与“多重映射”有关。与它有关的代码仅极少数而已。
+`DirMap`类可帮助我们实现这一效果，并有效地演示了一个“多重映射”的概述。这是通过一个散列表（`Hashtable`）实现的，它的“键”是准备创建的子目录，而“值”是包含了那个特定目录中的`SourceCodeFile`对象的`Vector`对象。所以，我们在这儿并不是将一个“键”映射（或对应）到一个值，而是通过对应的`Vector`，将一个键“多重映射”到一系列值。尽管这听起来似乎很复杂，但具体实现时却是非常简单和直接的。大家可以看到，`DirMap`类的大多数代码都与向文件中的写入有关，而非与“多重映射”有关。与它有关的代码仅极少数而已。
 
-可通过两种方式建立一个DirMap（目录映射或对应）关系：默认构造器假定我们希望目录从当前位置向下展开，而另一个构造器让我们为起始目录指定一个备用的“绝对”路径。
+可通过两种方式建立一个`DirMap`（目录映射或对应）关系：默认构造器假定我们希望目录从当前位置向下展开，而另一个构造器让我们为起始目录指定一个备用的“绝对”路径。
 
-add()方法是一个采取的行动比较密集的场所。首先将directory()从我们想添加的SourceCodeFile里提取出来，然后检查散列表（Hashtable），看看其中是否已经包含了那个键。如果没有，就向散列表加入一个新的Vector，并将它同那个键关联到一起。到这时，不管采取的是什么途径，Vector都已经就位了，可以将它提取出来，以便添加SourceCodeFile。由于Vector可象这样同散列表方便地合并到一起，所以我们从两方面都能感觉得非常方便。
+`add()`方法是一个采取的行动比较密集的场所。首先将`directory()`从我们想添加的`SourceCodeFile`里提取出来，然后检查散列表（`Hashtable`），看看其中是否已经包含了那个键。如果没有，就向散列表加入一个新的`Vector`，并将它同那个键关联到一起。到这时，不管采取的是什么途径，`Vector`都已经就位了，可以将它提取出来，以便添加`SourceCodeFile`。由于`Vector`可象这样同散列表方便地合并到一起，所以我们从两方面都能感觉得非常方便。
 
-写一个打包文件时，需打开一个准备写入的文件（当作DataOutputStream打开，使数据具有“通用”性），并在第一行写入与老的分隔符有关的头信息。接着产生对Hashtable键的一个Enumeration（枚举），并遍历其中，选择每一个目录，并取得与那个目录有关的Vector，使那个Vector中的每个SourceCodeFile都能写入打包文件中。
+写一个打包文件时，需打开一个准备写入的文件（当作`DataOutputStream`打开，使数据具有“通用”性），并在第一行写入与老的分隔符有关的头信息。接着产生对`Hashtable`键的一个`Enumeration`（枚举），并遍历其中，选择每一个目录，并取得与那个目录有关的Vector，使那个`Vector`中的每个`SourceCodeFile`都能写入打包文件中。
 
-用write()将Java源码文件写入它们对应的目录时，采用的方法几乎与writePackedFile()完全一致，因为两个方法都只需简单调用SourceCodeFile中适当的方法。但在这里，根路径会传递给SourceCodeFile.writeFile()。所有文件都写好后，名字中指定了已写文件数量的那个附加文件也会被写入。
+用`write()`将Java源码文件写入它们对应的目录时，采用的方法几乎与`writePackedFile()`完全一致，因为两个方法都只需简单调用`SourceCodeFile`中适当的方法。但在这里，根路径会传递给`SourceCodeFile.writeFile()`。所有文件都写好后，名字中指定了已写文件数量的那个附加文件也会被写入。
 
 5. 主程序
 
-前面介绍的那些类都要在CodePackager中用到。大家首先看到的是用法字符串。一旦最终用户不正确地调用了程序，就会打印出介绍正确用法的这个字符串。调用这个字符串的是usage()方法，同时还要退出程序。main()唯一的任务就是判断我们希望创建一个打包文件，还是希望从一个打包文件中提取什么东西。随后，它负责保证使用的是正确的参数，并调用适当的方法。
+前面介绍的那些类都要在`CodePackager`中用到。大家首先看到的是用法字符串。一旦最终用户不正确地调用了程序，就会打印出介绍正确用法的这个字符串。调用这个字符串的是`usage()`方法，同时还要退出程序。`main()`唯一的任务就是判断我们希望创建一个打包文件，还是希望从一个打包文件中提取什么东西。随后，它负责保证使用的是正确的参数，并调用适当的方法。
 
-创建一个打包文件时，它默认位于当前目录，所以我们用默认构造器创建DirMap。打开文件后，其中的每一行都会读入，并检查是否符合特殊的条件：
+创建一个打包文件时，它默认位于当前目录，所以我们用默认构造器创建`DirMap`。打开文件后，其中的每一行都会读入，并检查是否符合特殊的条件：
 
-(1) 若行首是一个用于源码列表的起始标记，就新建一个SourceCodeFile对象。构造器会读入源码列表剩下的所有内容。结果产生的引用将直接加入DirMap。
+(1) 若行首是一个用于源码列表的起始标记，就新建一个`SourceCodeFile`对象。构造器会读入源码列表剩下的所有内容。结果产生的引用将直接加入`DirMap`。
 
-(2) 若行首是一个用于源码列表的结束标记，表明某个地方出现错误，因为结束标记应当只能由SourceCodeFile构造器发现。
+(2) 若行首是一个用于源码列表的结束标记，表明某个地方出现错误，因为结束标记应当只能由`SourceCodeFile`构造器发现。
 
-提取／释放一个打包文件时，提取出来的内容可进入当前目录，亦可进入另一个备用目录。所以需要相应地创建DirMap对象。打开文件，并将第一行读入。老的文件路径分隔符信息将从这一行中提取出来。随后根据输入来创建第一个SourceCodeFile对象，它会加入DirMap。只要包含了一个文件，新的SourceCodeFile对象就会创建并加入（创建的最后一个用光输入内容后，会简单地返回，然后hasFile()会返回一个错误）。
+提取／释放一个打包文件时，提取出来的内容可进入当前目录，亦可进入另一个备用目录。所以需要相应地创建`DirMap`对象。打开文件，并将第一行读入。老的文件路径分隔符信息将从这一行中提取出来。随后根据输入来创建第一个`SourceCodeFile`对象，它会加入`DirMap`。只要包含了一个文件，新的`SourceCodeFile`对象就会创建并加入（创建的最后一个用光输入内容后，会简单地返回，然后`hasFile()`会返回一个错误）。
 
 17.1.2 检查大小写样式
 
-尽管对涉及文字处理的一些项目来说，前例显得比较方便，但下面要介绍的项目却能立即发挥作用，因为它执行的是一个样式检查，以确保我们的大小写形式符合“事实上”的Java样式标准。它会在当前目录中打开每个.java文件，并提取出所有类名以及标识符。若发现有不符合Java样式的情况，就向我们提出报告。
+尽管对涉及文字处理的一些项目来说，前例显得比较方便，但下面要介绍的项目却能立即发挥作用，因为它执行的是一个样式检查，以确保我们的大小写形式符合“事实上”的Java样式标准。它会在当前目录中打开每个`.java`文件，并提取出所有类名以及标识符。若发现有不符合Java样式的情况，就向我们提出报告。
 
-为了让这个程序正确运行，首先必须构建一个类名，将它作为一个“仓库”，负责容纳标准Java库中的所有类名。为达到这个目的，需遍历用于标准Java库的所有源码子目录，并在每个子目录都运行ClassScanner。至于参数，则提供仓库文件的名字（每次都用相同的路径和名字）和命令行开关-a，指出类名应当添加到该仓库文件中。
+为了让这个程序正确运行，首先必须构建一个类名，将它作为一个“仓库”，负责容纳标准Java库中的所有类名。为达到这个目的，需遍历用于标准Java库的所有源码子目录，并在每个子目录都运行`ClassScanner`。至于参数，则提供仓库文件的名字（每次都用相同的路径和名字）和命令行开关`-a`，指出类名应当添加到该仓库文件中。
 
 为了用程序检查自己的代码，需要运行它，并向它传递要使用的仓库文件的路径与名字。它会检查当前目录中的所有类和标识符，并告诉我们哪些没有遵守典型的Java大写写规范。
 
@@ -573,7 +573,7 @@ public class ClassScanner {
   private File path;
   private String[] fileList;
   private Properties classes = new Properties();
-  private MultiStringMap 
+  private MultiStringMap
     classMap = new MultiStringMap(),
     identMap = new MultiStringMap();
   private StreamTokenizer in;
@@ -597,18 +597,18 @@ public class ClassScanner {
       in.ordinaryChar('.');
       in.wordChars('_', '_');
       in.eolIsSignificant(true);
-      while(in.nextToken() != 
+      while(in.nextToken() !=
             StreamTokenizer.TT_EOF) {
         if(in.ttype == '/')
           eatComments();
-        else if(in.ttype == 
+        else if(in.ttype ==
                 StreamTokenizer.TT_WORD) {
-          if(in.sval.equals("class") || 
+          if(in.sval.equals("class") ||
              in.sval.equals("interface")) {
             // Get class name:
-               while(in.nextToken() != 
+               while(in.nextToken() !=
                      StreamTokenizer.TT_EOF
-                     && in.ttype != 
+                     && in.ttype !=
                      StreamTokenizer.TT_WORD)
                  ;
                classes.put(in.sval, in.sval);
@@ -627,9 +627,9 @@ public class ClassScanner {
   }
   void discardLine() {
     try {
-      while(in.nextToken() != 
+      while(in.nextToken() !=
             StreamTokenizer.TT_EOF
-            && in.ttype != 
+            && in.ttype !=
             StreamTokenizer.TT_EOL)
         ; // Throw away tokens to end of line
     } catch(IOException e) {
@@ -640,19 +640,19 @@ public class ClassScanner {
   // to be broken. This extracts them:
   void eatComments() {
     try {
-      if(in.nextToken() != 
+      if(in.nextToken() !=
          StreamTokenizer.TT_EOF) {
         if(in.ttype == '/')
           discardLine();
         else if(in.ttype != '*')
           in.pushBack();
-        else 
+        else
           while(true) {
-            if(in.nextToken() == 
+            if(in.nextToken() ==
               StreamTokenizer.TT_EOF)
               break;
             if(in.ttype == '*')
-              if(in.nextToken() != 
+              if(in.nextToken() !=
                 StreamTokenizer.TT_EOF
                 && in.ttype == '/')
                 break;
@@ -676,13 +676,13 @@ public class ClassScanner {
       String file = (String)files.nextElement();
       Vector cls = classMap.getVector(file);
       for(int i = 0; i < cls.size(); i++) {
-        String className = 
+        String className =
           (String)cls.elementAt(i);
         if(Character.isLowerCase(
              className.charAt(0)))
           System.out.println(
             "class capitalization error, file: "
-            + file + ", class: " 
+            + file + ", class: "
             + className);
       }
     }
@@ -694,7 +694,7 @@ public class ClassScanner {
       String file = (String)files.nextElement();
       Vector ids = identMap.getVector(file);
       for(int i = 0; i < ids.size(); i++) {
-        String id = 
+        String id =
           (String)ids.elementAt(i);
         if(!classes.contains(id)) {
           // Ignore identifiers of length 3 or
@@ -719,7 +719,7 @@ public class ClassScanner {
     }
   }
   static final String usage =
-    "Usage: \n" + 
+    "Usage: \n" +
     "ClassScanner classnames -a\n" +
     "\tAdds all the class names in this \n" +
     "\tdirectory to the repository file \n" +
@@ -739,7 +739,7 @@ public class ClassScanner {
     File old = new File(args[0]);
     if(old.exists()) {
       try {
-        // Try to open an existing 
+        // Try to open an existing
         // properties file:
         InputStream oldlist =
           new BufferedInputStream(
@@ -785,34 +785,34 @@ class JavaFilter implements FilenameFilter {
 } ///:~
 ```
 
-MultiStringMap类是个特殊的工具，允许我们将一组字符串与每个键项对应（映射）起来。和前例一样，这里也使用了一个散列表（Hashtable），不过这次设置了继承。该散列表将键作为映射成为Vector值的单一的字符串对待。add()方法的作用很简单，负责检查散列表里是否存在一个键。如果不存在，就在其中放置一个。getVector()方法为一个特定的键产生一个Vector；而printValues()将所有值逐个Vector地打印出来，这对程序的调试非常有用。
+`MultiStringMap`类是个特殊的工具，允许我们将一组字符串与每个键项对应（映射）起来。和前例一样，这里也使用了一个散列表（`Hashtable`），不过这次设置了继承。该散列表将键作为映射成为`Vector`值的单一的字符串对待。`add()`方法的作用很简单，负责检查散列表里是否存在一个键。如果不存在，就在其中放置一个。`getVector()`方法为一个特定的键产生一个`Vector`；而`printValues()`将所有值逐个`Vector`地打印出来，这对程序的调试非常有用。
 
-为简化程序，来自标准Java库的类名全都置入一个Properties（属性）对象中（来自标准Java库）。记住Properties对象实际是个散列表，其中只容纳了用于键和值项的String对象。然而仅需一次方法调用，我们即可把它保存到磁盘，或者从磁盘中恢复。实际上，我们只需要一个名字列表，所以为键和值都使用了相同的对象。
+为简化程序，来自标准Java库的类名全都置入一个`Properties`（属性）对象中（来自标准Java库）。记住`Properties`对象实际是个散列表，其中只容纳了用于键和值项的`String`对象。然而仅需一次方法调用，我们即可把它保存到磁盘，或者从磁盘中恢复。实际上，我们只需要一个名字列表，所以为键和值都使用了相同的对象。
 
-针对特定目录中的文件，为找出相应的类与标识符，我们使用了两个MultiStringMap：classMap以及identMap。此外在程序启动的时候，它会将标准类名仓库装载到名为classes的Properties对象中。一旦在本地目录发现了一个新类名，也会将其加入classes以及classMap。这样一来，classMap就可用于在本地目录的所有类间遍历，而且可用classes检查当前标记是不是一个类名（它标记着对象或方法定义的开始，所以收集接下去的记号——直到碰到一个分号——并将它们都置入identMap）。
+针对特定目录中的文件，为找出相应的类与标识符，我们使用了两个`MultiStringMap`：`classMap`以及`identMap`。此外在程序启动的时候，它会将标准类名仓库装载到名为`classes`的`Properties`对象中。一旦在本地目录发现了一个新类名，也会将其加入`classes`以及`classMap`。这样一来，`classMap`就可用于在本地目录的所有类间遍历，而且可用`classes`检查当前标记是不是一个类名（它标记着对象或方法定义的开始，所以收集接下去的记号——直到碰到一个分号——并将它们都置入`identMap`）。
 
-ClassScanner的默认构造器会创建一个由文件名构成的列表（采用FilenameFilter的JavaFilter实现形式，参见第10章）。随后会为每个文件名都调用scanListing()。
+`ClassScanner`的默认构造器会创建一个由文件名构成的列表（采用`FilenameFilter`的`JavaFilter`实现形式，参见第10章）。随后会为每个文件名都调用`scanListing()`。
 
-在scanListing()内部，会打开源码文件，并将其转换成一个StreamTokenizer。根据Java帮助文档，将true传递给slashStartComments()和slashSlashComments()的本意应当是剥除那些注释内容，但这样做似乎有些问题（在Java 1.0中几乎无效）。所以相反，那些行被当作注释标记出去，并用另一个方法来提取注释。为达到这个目的，'/'必须作为一个原始字符捕获，而不是让StreamTokeinzer将其当作注释的一部分对待。此时要用ordinaryChar()方法指示StreamTokenizer采取正确的操作。同样的道理也适用于点号（'.'），因为我们希望让方法调用分离出单独的标识符。但对下划线来说，它最初是被StreamTokenizer当作一个单独的字符对待的，但此时应把它留作标识符的一部分，因为它在static final值中以TT_EOF等等形式使用。当然，这一点只对目前这个特殊的程序成立。wordChars()方法需要取得我们想添加的一系列字符，把它们留在作为一个单词看待的记号中。最后，在解析单行注释或者放弃一行的时候，我们需要知道一个换行动作什么时候发生。所以通过调用eollsSignificant(true)，换行符（EOL）会被显示出来，而不是被StreamTokenizer吸收。
+在`scanListing()`内部，会打开源码文件，并将其转换成一个`StreamTokenizer`。根据Java帮助文档，将`true`传递给`slashStartComments()`和`slashSlashComments()`的本意应当是剥除那些注释内容，但这样做似乎有些问题（在Java 1.0中几乎无效）。所以相反，那些行被当作注释标记出去，并用另一个方法来提取注释。为达到这个目的，`'/'`必须作为一个原始字符捕获，而不是让`StreamTokeinzer`将其当作注释的一部分对待。此时要用`ordinaryChar()`方法指示`StreamTokenizer`采取正确的操作。同样的道理也适用于点号（`'.'`），因为我们希望让方法调用分离出单独的标识符。但对下划线来说，它最初是被`StreamTokenizer`当作一个单独的字符对待的，但此时应把它留作标识符的一部分，因为它在`static final`值中以`TT_EOF`等等形式使用。当然，这一点只对目前这个特殊的程序成立。`wordChars()`方法需要取得我们想添加的一系列字符，把它们留在作为一个单词看待的记号中。最后，在解析单行注释或者放弃一行的时候，我们需要知道一个换行动作什么时候发生。所以通过调用`eollsSignificant(true)`，换行符（`EOL`）会被显示出来，而不是被`StreamTokenizer`吸收。
 
-scanListing()剩余的部分将读入和检查记号，直至文件尾。一旦nextToken()返回一个final static值——StreamTokenizer.TT_EOF，就标志着已经抵达文件尾部。
+`scanListing()`剩余的部分将读入和检查记号，直至文件尾。一旦`nextToken()`返回一个`final static`值——`StreamTokenizer.TT_EOF`，就标志着已经抵达文件尾部。
 
-若记号是个'/'，意味着它可能是个注释，所以就调用eatComments()，对这种情况进行处理。我们在这儿唯一感兴趣的其他情况是它是否为一个单词，当然还可能存在另一些特殊情况。
+若记号是个`'/'`，意味着它可能是个注释，所以就调用`eatComments()`，对这种情况进行处理。我们在这儿唯一感兴趣的其他情况是它是否为一个单词，当然还可能存在另一些特殊情况。
 
-如果单词是class（类）或interface（接口），那么接着的记号就应当代表一个类或接口名字，并将其置入classes和classMap。若单词是import或者package，那么我们对这一行剩下的东西就没什么兴趣了。其他所有东西肯定是一个标识符（这是我们感兴趣的），或者是一个关键字（对此不感兴趣，但它们采用的肯定是小写形式，所以不必兴师动众地检查它们）。它们将加入到identMap。
+如果单词是`class`（类）或`interface`（接口），那么接着的记号就应当代表一个类或接口名字，并将其置入`classes`和`classMap`。若单词是`import`或者`package`，那么我们对这一行剩下的东西就没什么兴趣了。其他所有东西肯定是一个标识符（这是我们感兴趣的），或者是一个关键字（对此不感兴趣，但它们采用的肯定是小写形式，所以不必兴师动众地检查它们）。它们将加入到`identMap`。
 
-discardLine()方法是一个简单的工具，用于查找行末位置。注意每次得到一个新记号时，都必须检查行末。
+`discardLine()`方法是一个简单的工具，用于查找行末位置。注意每次得到一个新记号时，都必须检查行末。
 
-只要在主解析循环中碰到一个正斜杠，就会调用eatComments()方法。然而，这并不表示肯定遇到了一条注释，所以必须将接着的记号提取出来，检查它是一个正斜杠（那么这一行会被丢弃），还是一个星号。但假如两者都不是，意味着必须在主解析循环中将刚才取出的记号送回去！幸运的是，pushBack()方法允许我们将当前记号“压回”输入数据流。所以在主解析循环调用nextToken()的时候，它能正确地得到刚才送回的东西。
+只要在主解析循环中碰到一个正斜杠，就会调用`eatComments()`方法。然而，这并不表示肯定遇到了一条注释，所以必须将接着的记号提取出来，检查它是一个正斜杠（那么这一行会被丢弃），还是一个星号。但假如两者都不是，意味着必须在主解析循环中将刚才取出的记号送回去！幸运的是，`pushBack()`方法允许我们将当前记号“压回”输入数据流。所以在主解析循环调用`nextToken()`的时候，它能正确地得到刚才送回的东西。
 
-为方便起见，classNames()方法产生了一个数组，其中包含了classes集合中的所有名字。这个方法未在程序中使用，但对代码的调试非常有用。
+为方便起见，`classNames()`方法产生了一个数组，其中包含了`classes`集合中的所有名字。这个方法未在程序中使用，但对代码的调试非常有用。
 
-接下来的两个方法是实际进行检查的地方。在checkClassNames()中，类名从classMap提取出来（请记住，classMap只包含了这个目录内的名字，它们按文件名组织，所以文件名可能伴随错误的类名打印出来）。为做到这一点，需要取出每个关联的Vector，并遍历其中，检查第一个字符是否为小写。若确实为小写，则打印出相应的出错提示消息。
+接下来的两个方法是实际进行检查的地方。在`checkClassNames()`中，类名从`classMap`提取出来（请记住，`classMap`只包含了这个目录内的名字，它们按文件名组织，所以文件名可能伴随错误的类名打印出来）。为做到这一点，需要取出每个关联的`Vector`，并遍历其中，检查第一个字符是否为小写。若确实为小写，则打印出相应的出错提示消息。
 
-在checkIdentNames()中，我们采用了一种类似的方法：每个标识符名字都从identMap中提取出来。如果名字不在classes列表中，就认为它是一个标识符或者关键字。此时会检查一种特殊情况：如果标识符的长度等于3或者更长，而且所有字符都是大写的，则忽略此标识符，因为它可能是一个static final值，比如TT_EOF。当然，这并不是一种完美的算法，但它假定我们最终会注意到任何全大写标识符都是不合适的。
+在`checkIdentNames()`中，我们采用了一种类似的方法：每个标识符名字都从`identMap`中提取出来。如果名字不在`classes`列表中，就认为它是一个标识符或者关键字。此时会检查一种特殊情况：如果标识符的长度等于3或者更长，而且所有字符都是大写的，则忽略此标识符，因为它可能是一个`static fina`l值，比如`TT_EOF`。当然，这并不是一种完美的算法，但它假定我们最终会注意到任何全大写标识符都是不合适的。
 
-这个方法并不是报告每一个以大写字符开头的标识符，而是跟踪那些已在一个名为reportSet()的Vector中报告过的。它将Vector当作一个“集合”对待，告诉我们一个项目是否已在那个集合中。该项目是通过将文件名和标识符连接起来生成的。若元素不在集合中，就加入它，然后产生报告。
+这个方法并不是报告每一个以大写字符开头的标识符，而是跟踪那些已在一个名为`reportSet()`的`Vector`中报告过的。它将`Vector`当作一个“集合”对待，告诉我们一个项目是否已在那个集合中。该项目是通过将文件名和标识符连接起来生成的。若元素不在集合中，就加入它，然后产生报告。
 
-程序列表剩下的部分由main()构成，它负责控制命令行参数，并判断我们是准备在标准Java库的基础上构建由一系列类名构成的“仓库”，还是想检查已写好的那些代码的正确性。不管在哪种情况下，都会创建一个ClassScanner对象。
+程序列表剩下的部分由`main()`构成，它负责控制命令行参数，并判断我们是准备在标准Java库的基础上构建由一系列类名构成的“仓库”，还是想检查已写好的那些代码的正确性。不管在哪种情况下，都会创建一个`ClassScanner`对象。
 
-无论准备构建一个“仓库”，还是准备使用一个现成的，都必须尝试打开现有仓库。通过创建一个File对象并测试是否存在，就可决定是否打开文件并在ClassScanner中装载classes这个Properties列表（使用load()）。来自仓库的类将追加到由ClassScanner构造器发现的类后面，而不是将其覆盖。如果仅提供一个命令行参数，就意味着自己想对类名和标识符名字进行一次检查。但假如提供两个参数（第二个是"-a"），就表明自己想构成一个类名仓库。在这种情况下，需要打开一个输出文件，并用Properties.save()方法将列表写入一个文件，同时用一个字符串提供文件头信息。
+无论准备构建一个“仓库”，还是准备使用一个现成的，都必须尝试打开现有仓库。通过创建一个`File`对象并测试是否存在，就可决定是否打开文件并在`ClassScanner`中装载`classes`这个`Properties`列表（使用`load()`）。来自仓库的类将追加到由`ClassScanner`构造器发现的类后面，而不是将其覆盖。如果仅提供一个命令行参数，就意味着自己想对类名和标识符名字进行一次检查。但假如提供两个参数（第二个是`-a`），就表明自己想构成一个类名仓库。在这种情况下，需要打开一个输出文件，并用`Properties.save()`方法将列表写入一个文件，同时用一个字符串提供文件头信息。

17.2 方法查找工具.md

@@ -19,10 +19,10 @@ public class DisplayMethods extends Applet {
   Method[] m;
   Constructor[] ctor;
   String[] n = new String[0];
-  TextField 
+  TextField
     name = new TextField(40),
     searchFor = new TextField(30);
-  Checkbox strip = 
+  Checkbox strip =
     new Checkbox("Strip Qualifiers");
   TextArea results = new TextArea(40, 65);
   public void init() {
@@ -30,7 +30,7 @@ public class DisplayMethods extends Applet {
     name.addTextListener(new NameL());
     searchFor.addTextListener(new SearchForL());
     strip.addItemListener(new StripL());
-    Panel 
+    Panel
       top = new Panel(),
       lower = new Panel(),
       p = new Panel();
@@ -152,7 +152,7 @@ class StripQualifiers {
     return s;
   }
   public static String strip(String qualified) {
-    StripQualifiers sq = 
+    StripQualifiers sq =
       new StripQualifiers(qualified);
     String s = "", si;
     while((si = sq.getNext()) != null) {
@@ -166,14 +166,14 @@ class StripQualifiers {
 } ///:~
 ```
 
-程序中的有些东西已在以前见识过了。和本书的许多GUI程序一样，这既可作为一个独立的应用程序使用，亦可作为一个程序片（Applet）使用。此外，StripQualifiers类与它在第11章的表现是完全一样的。
+程序中的有些东西已在以前见识过了。和本书的许多GUI程序一样，这既可作为一个独立的应用程序使用，亦可作为一个程序片（Applet）使用。此外，`StripQualifiers`类与它在第11章的表现是完全一样的。
 
-GUI包含了一个名为name的“文本字段”（TextField），或在其中输入想查找的类名；还包含了另一个文本字段，名为searchFor，可选择性地在其中输入一定的文字，希望在方法列表中查找那些文字。Checkbox（复选框）允许我们指出最终希望在输出中使用完整的名字，还是将前面的各种限定信息删去。最后，结果显示于一个“文本区域”（TextArea）中。
+GUI包含了一个名为`name`的“文本字段”（`TextField`），或在其中输入想查找的类名；还包含了另一个文本字段，名为`searchFor`，可选择性地在其中输入一定的文字，希望在方法列表中查找那些文字。`Checkbox`（复选框）允许我们指出最终希望在输出中使用完整的名字，还是将前面的各种限定信息删去。最后，结果显示于一个“文本区域”（`TextArea`）中。
 
-大家会注意到这个程序未使用任何按钮或其他组件，不能用它们开始一次搜索。这是由于无论文本字段还是复选框都会受到它们的“侦听者（Listener）对象的监视。只要作出一项改变，结果列表便会立即更新。若改变了name字段中的文字，新的文字就会在NameL类中捕获。若文字不为空，则在Class.forName()中用于尝试查找类。当然，在文字键入期间，名字可能会变得不完整，而Class.forName()会失败，这意味着它会“抛”出一个异常。该异常会被捕获，TextArea会随之设为“Nomatch”（没有相符）。但只要键入了一个正确的名字（大小写也算在内），Class.forName()就会成功，而getMethods()和getConstructors()会分别返回由Method和Constructor对象构成的一个数组。这些数组中的每个对象都会通过toString()转变成一个字符串（这样便产生了完整的方法或构造器签名），而且两个列表都会合并到n中——一个独立的字符串数组。数组n属于DisplayMethods类的一名成员，并在调用reDisplay()时用于显示的更新。
+大家会注意到这个程序未使用任何按钮或其他组件，不能用它们开始一次搜索。这是由于无论文本字段还是复选框都会受到它们的“监听者（`Listener`）对象的监视。只要作出一项改变，结果列表便会立即更新。若改变了`name`字段中的文字，新的文字就会在`NameL`类中捕获。若文字不为空，则在`Class.forName()`中用于尝试查找类。当然，在文字键入期间，名字可能会变得不完整，而`Class.forName()`会失败，这意味着它会“抛”出一个异常。该异常会被捕获，`TextArea`会随之设为`Nomatch`（不相符）。但只要键入了一个正确的名字（大小写也算在内），`Class.forName()`就会成功，而`getMethods()`和`getConstructors()`会分别返回由`Method`和`Constructor`对象构成的一个数组。这些数组中的每个对象都会通过`toString()`转变成一个字符串（这样便产生了完整的方法或构造器签名），而且两个列表都会合并到`n`中——一个独立的字符串数组。数组`n`属于`DisplayMethods`类的一名成员，并在调用`reDisplay()`时用于显示的更新。
 
-若改变了Checkbox或searchFor组件，它们的“侦听者”会简单地调用reDisplay()。reDisplay()会创建一个临时数组，其中包含了名为rs的字符串（rs代表“结果集”——Result Set）。结果集要么直接从n复制（没有find关键字），要么选择性地从包含了find关键字的n中的字符串复制。最后会检查strip Checkbox，看看用户是不是希望将名字中多余的部分删除（默认为“是”）。若答案是肯定的，则用StripQualifiers.strip()做这件事情；反之，就将列表简单地显示出来。
+若改变了`Checkbox`或`searchFor`组件，它们的“监听者”会简单地调用`reDisplay()`。`reDisplay()`会创建一个临时数组，其中包含了名为`rs`的字符串（`rs`代表“结果集”——`Result Set`）。结果集要么直接从`n`复制（没有`find`关键字），要么选择性地从包含了`find`关键字的`n`中的字符串复制。最后会检查`strip Checkbox`，看看用户是不是希望将名字中多余的部分删除（默认为“是”）。若答案是肯定的，则用`StripQualifiers.strip()`做这件事情；反之，就将列表简单地显示出来。
 
-在init()中，大家也许认为在设置布局时需要进行大量繁重的工作。事实上，组件的布置完全可能只需要极少的工作。但象这样使用BorderLayout的好处是它允许用户改变窗口的大小，并特别能使TextArea（文本区域）更大一些，这意味着我们可以改变大小，以便毋需滚动即可看到更长的名字。
+在`init()`中，大家也许认为在设置布局时需要进行大量繁重的工作。事实上，组件的布置完全可能只需要极少的工作。但象这样使用`BorderLayout`的好处是它允许用户改变窗口的大小，并特别能使`TextArea`（文本区域）更大一些，这意味着我们可以改变大小，以便毋需滚动即可看到更长的名字。
 
 编程时，大家会发现特别有必要让这个工具处于运行状态，因为在试图判断要调用什么方法的时候，它提供了最好的方法之一。

17.5 练习.md

 # 17.5 练习
 
-(1) （稍微有些难度）改写FieldOBeasts.java，使它的状态能够保持固定。加上一些按钮，允许用户保存和恢复不同的状态文件，并从它们断掉的地方开始继续运行。请先参考第10章的CADState.java，再决定具体怎样做。
+(1) （稍微有些难度）改写`FieldOBeasts.java`，使它的状态能够保持固定。加上一些按钮，允许用户保存和恢复不同的状态文件，并从它们断掉的地方开始继续运行。请先参考第10章的`CADState.java`，再决定具体怎样做。
 
-(2) （大作业）以FieldOBeasts.java作为起点，构造一个自动化交通仿真系统。
+(2) （大作业）以`FieldOBeasts.java`作为起点，构造一个自动化交通仿真系统。
 
-(3) （大作业）以ClassScanner.java作为起点，构造一个特殊的工具，用它找出那些虽然定义但从未用过的方法和字段。
+(3) （大作业）以`ClassScanner.java`作为起点，构造一个特殊的工具，用它找出那些虽然定义但从未用过的方法和字段。
 
-(4) （大作业）利用JDBC，构造一个联络管理程序。让这个程序以一个平面文件数据库为基础，其中包含了名字、地址、电话号码、E-mail地址等联系资料。应该能向数据库里方便地加入新名字。键入要查找的名字时，请采用在第15章的VLookup.java里介绍过的那种名字自动填充技术。
+(4) （大作业）利用JDBC，构造一个联络管理程序。让这个程序以一个平面文件数据库为基础，其中包含了名字、地址、电话号码、E-mail地址等联系资料。应该能向数据库里方便地加入新名字。键入要查找的名字时，请采用在第15章的`VLookup.java`里介绍过的那种名字自动填充技术。
\ No newline at end of file