chs

引言.md

@@ -8,7 +8,7 @@
 
 #### 1. 前提
 
-本书假定读者对编程多少有些熟悉。应已知道程序是一系列语句的集合，知道子程序／函数／宏是什么，知道象“If”这样的控制语句，也知道象“while”这样的循环结构。注意这些东西在大量语言里都是类似的。假如您学过一种宏语言，或者用过Perl之类的工具，那么它们的基本概念并无什么区别。总之，只要能习惯基本的编程概念，就可顺利阅读本书。当然，C/C++程序员在阅读时能占到更多的便宜。但即使不熟悉C，一样不要把自己排除在外（尽管以后的学习要付出更大的努力）。我会讲述面向对象编程的概念，以及Java的基本控制机制，所以不用担心自己会打不好基础。况且，您需要学习的第一类知识就会涉及到基本的流程控制语句。
+本书假定读者对编程多少有些熟悉。应已知道程序是一系列语句的集合，知道子程序／函数／宏是什么，知道象`If`这样的控制语句，也知道象`while`这样的循环结构。注意这些东西在大量语言里都是类似的。假如您学过一种宏语言，或者用过Perl之类的工具，那么它们的基本概念并无什么区别。总之，只要能习惯基本的编程概念，就可顺利阅读本书。当然，C/C++程序员在阅读时能占到更多的便宜。但即使不熟悉C，一样不要把自己排除在外（尽管以后的学习要付出更大的努力）。我会讲述面向对象编程的概念，以及Java的基本控制机制，所以不用担心自己会打不好基础。况且，您需要学习的第一类知识就会涉及到基本的流程控制语句。
 
 尽管经常都会谈及C和C++语言的一些特性，但并没有打算使它们成为内部参考，而是想帮助所有程序员都能正确地看待那两种语言。毕竟，Java是从它们那里派生出来的。我将试着尽可能地简化这些引用和参考，并合理地解释一名非C/C++程序员通常不太熟悉的内容。
 
@@ -16,7 +16,7 @@
 
 在我第一本书《Using C++》面市的几乎同一时间（Osborne/McGraw-Hill于1989年出版），我开始教授那种语言。程序设计语言的教授已成为我的专业。自1989年以来，我便在世界各地见过许多昏昏欲睡、满脸茫然以及困惑不解的面容。开始在室内面向较少的一组人授课以后，我从作业中发现了一些特别的问题。即使那些上课面带会心的微笑或者频频点头的学生，对许多问题也存在认识上的混淆。在过去几年间的“软件开发会议”上，由我主持C++分组讨论会（现在变成了Java讨论会）。有的演讲人试图在很短的时间内向听众灌输过多的主题。所以到最后，尽管听众的水平都还可以，而且提供的材料也很充足，但仍然损失了一部分听众。这可能是由于问得太多了，但由于我是那些采取传统授课方式的人之一，所以很想使每个人都能跟上讲课进度。
 
-有段时间，我编制了大量教学简报。经过不断的试验和修订（或称“迭代”，这是在Java程序设计中非常有用的一项技术），最后成功地在一门课程中集成了从我的教学经验中总结出来的所有东西——我在很长一段时间里都在使用。其中由一系列离散的、易于消化的小步骤组成，而且每个小课程结束后都有一些适当的练习。我目前已在Java公开研讨会上公布了这一课程，大家可到http://www.BruceEckel.com了解详情（对研讨会的介绍也以CD-ROM的形式提供，具体信息可在同样的Web站点找到）。
+有段时间，我编制了大量教学简报。经过不断的试验和修订（或称“迭代”，这是在Java程序设计中非常有用的一项技术），最后成功地在一门课程中集成了从我的教学经验中总结出来的所有东西——我在很长一段时间里都在使用。其中由一系列离散的、易于消化的小步骤组成，而且每个小课程结束后都有一些适当的练习。我目前已在Java公开研讨会上公布了这一课程，大家可到`http://www.BruceEckel.com`了解详情（对研讨会的介绍也以CD-ROM的形式提供，具体信息可在同样的Web站点找到）。
 
 从每一次研讨会收到的反馈都帮助我修改及重新制订学习材料的重心，直到我最后认为它成为一个完善的教学载体为止。但本书并非仅仅是一本教科书——我尝试在其中装入尽可能多的信息，并按照主题进行了有序的分类。无论如何，这本书的主要宗旨是为那些独立学习的人士服务，他们正准备深入一门新的程序设计语言，而没有太大的可能参加此类专业研讨会。
 
@@ -59,15 +59,15 @@
 
 **(3) 第3章：控制程序流程**
 
-本章开始介绍起源于C和C++，由Java继承的所有运算符。除此以外，还要学习运算符一些不易使人注意的问题，以及涉及转换、升迁以及优先次序的问题。随后要讲述的是基本的流程控制以及选择运算，这些是几乎所有程序设计语言都具有的特性：用if-else实现选择；用for和while实现循环；用break和continue以及Java的标签式break和contiune（它们被认为是Java中“不见的gogo”）退出循环；以及用switch实现另一种形式的选择。尽管这些与C和C++中见到的有一定的共通性，但多少存在一些区别。除此以外，所有示例都是完整的Java示例，能使大家很快地熟悉Java的外观。
+本章开始介绍起源于C和C++，由Java继承的所有运算符。除此以外，还要学习运算符一些不易使人注意的问题，以及涉及转换、升迁以及优先次序的问题。随后要讲述的是基本的流程控制以及选择运算，这些是几乎所有程序设计语言都具有的特性：用`if-else`实现选择；用`for`和`while`实现循环；用`break`和`continue`以及Java的标签式`break`和`contiune`（它们被认为是Java中“不见的`goto`”）退出循环；以及用`switch`实现另一种形式的选择。尽管这些与C和C++中见到的有一定的共通性，但多少存在一些区别。除此以外，所有示例都是完整的Java示例，能使大家很快地熟悉Java的外观。
 
 **(4) 第4章：初始化和清除**
 
-本章开始介绍构造器，它的作用是担保初始化的正确实现。对构造器的定义要涉及函数重载的概念（因为可能同时有几个构造器）。随后要讨论的是清除过程，它并非肯定如想象的那么简单。用完一个对象后，通常可以不必管它，垃圾收集器会自动介入，释放由它占据的内存。这里详细探讨了垃圾收集器以及它的一些特点。在这一章的最后，我们将更贴近地观察初始化过程：自动成员初始化、指定成员初始化、初始化的顺序、static（静态）初始化以及数组初始化等等。
+本章开始介绍构造器，它的作用是担保初始化的正确实现。对构造器的定义要涉及函数重载的概念（因为可能同时有几个构造器）。随后要讨论的是清除过程，它并非肯定如想象的那么简单。用完一个对象后，通常可以不必管它，垃圾收集器会自动介入，释放由它占据的内存。这里详细探讨了垃圾收集器以及它的一些特点。在这一章的最后，我们将更贴近地观察初始化过程：自动成员初始化、指定成员初始化、初始化的顺序、`static`（静态）初始化以及数组初始化等等。
 
 **(5) 第5章：隐藏实现过程**
 
-本章要探讨将代码封装到一起的方式，以及在库的其他部分隐藏时，为什么仍有一部分处于暴露状态。首先要讨论的是package和import关键字，它们的作用是进行文件级的封装（打包）操作，并允许我们构建由类构成的库（类库）。此时也会谈到目录路径和文件名的问题。本章剩下的部分将讨论public，private以及protected三个关键字、“友好”访问的概念以及各种场合下不同访问控制级的意义。
+本章要探讨将代码封装到一起的方式，以及在库的其他部分隐藏时，为什么仍有一部分处于暴露状态。首先要讨论的是`package`和`import`关键字，它们的作用是进行文件级的封装（打包）操作，并允许我们构建由类构成的库（类库）。此时也会谈到目录路径和文件名的问题。本章剩下的部分将讨论`public`，`private`以及`protected`三个关键字、“友好”访问的概念以及各种场合下不同访问控制级的意义。
 
 **(6) 第6章：类复用**
 
@@ -79,11 +79,11 @@
 
 **(8) 第8章：对象的容纳**
 
-对一个非常简单的程序来说，它可能只拥有一个固定数量的对象，而且对象的“生存时间”或者“存在时间”是已知的。但是通常，我们的程序会在不定的时间创建新对象，只有在程序运行时才可了解到它们的详情。此外，除非进入运行期，否则无法知道所需对象的数量，甚至无法得知它们确切的类型。为解决这个常见的程序设计问题，我们需要拥有一种能力，可在任何时间、任何地点创建任何数量的对象。本章的宗旨便是探讨在使用对象的同时用来容纳它们的一些Java工具：从简单的数组到复杂的集合（数据结构），如Vector和Hashtable等。最后，我们还会深入讨论新型和改进过的Java 1.2集合库。
+对一个非常简单的程序来说，它可能只拥有一个固定数量的对象，而且对象的“生存时间”或者“存在时间”是已知的。但是通常，我们的程序会在不定的时间创建新对象，只有在程序运行时才可了解到它们的详情。此外，除非进入运行期，否则无法知道所需对象的数量，甚至无法得知它们确切的类型。为解决这个常见的程序设计问题，我们需要拥有一种能力，可在任何时间、任何地点创建任何数量的对象。本章的宗旨便是探讨在使用对象的同时用来容纳它们的一些Java工具：从简单的数组到复杂的集合（数据结构），如`Vector`和`Hashtable`等。最后，我们还会深入讨论新型和改进过的Java 1.2集合库。
 
 **(9) 第9章：异常差错控制**
 
-Java最基本的设计宗旨之一便是组织错误的代码不会真的运行起来。编译器会尽可能捕获问题。但某些情况下，除非进入运行期，否则问题是不会被发现的。这些问题要么属于编程错误，要么则是一些自然的出错状况，它们只有在作为程序正常运行的一部分时才会成立。Java为此提供了“异常控制”机制，用于控制程序运行时产生的一切问题。这一章将解释try、catch、throw、throws以及finally等关键字在Java中的工作原理。并讲述什么时候应当“抛”出异常，以及在捕获到异常后该采取什么操作。此外，大家还会学习Java的一些标准异常，如何构建自己的异常，异常发生在构造器中怎么办，以及异常控制器如何定位等等。
+Java最基本的设计宗旨之一便是组织错误的代码不会真的运行起来。编译器会尽可能捕获问题。但某些情况下，除非进入运行期，否则问题是不会被发现的。这些问题要么属于编程错误，要么则是一些自然的出错状况，它们只有在作为程序正常运行的一部分时才会成立。Java为此提供了“异常控制”机制，用于控制程序运行时产生的一切问题。这一章将解释`try`、`catch`、`throw`、`throws`以及`finally`等关键字在Java中的工作原理。并讲述什么时候应当“抛”出异常，以及在捕获到异常后该采取什么操作。此外，大家还会学习Java的一些标准异常，如何构建自己的异常，异常发生在构造器中怎么办，以及异常控制器如何定位等等。
 
 **(10) 第10章：Java IO系统**
 
@@ -143,11 +143,13 @@ Java提供了一套内建的机制，可提供对多个并发子任务的支持
 列出我感觉特别有用的一系列Java参考书。
 
 #### 6. 练习
+
 为巩固对新知识的掌握，我发现简单的练习特别有用。所以读者在每一章结束时都能找到一系列练习。
 大多数练习都很简单，在合理的时间内可以完成。如将本书作为教材，可考虑在课堂内完成。老师要注意观察，确定所有学生都已消化了讲授的内容。有些练习要难些，他们是为那些有兴趣深入的读者准备的。大多数练习都可在较短时间内做完，有效地检测和加深您的知识。有些题目比较具有挑战性，但都不会太麻烦。事实上，练习中碰到的问题在实际应用中也会经常碰到。
 
 #### 7. 多媒体CD-ROM
-本书配套提供了一片多媒体CD-ROM，可单独购买及使用。它与其他计算机书籍的普通配套CD不同，那些CD通常仅包含了书中用到的源码（本书的源码可从www.BruceEckel.com免费下载）。本CD-ROM是一个独立的产品，包含了一周“Hads-OnJava”培训课程的全部内容。这是一个由Bruce Eckel讲授的、长度在15小时以上的课程，含500张以上的演示幻灯片。该课程建立在这本书的基础上，所以是非常理想的一个配套产品。
+
+本书配套提供了一片多媒体CD-ROM，可单独购买及使用。它与其他计算机书籍的普通配套CD不同，那些CD通常仅包含了书中用到的源码（本书的源码可从`www.BruceEckel.com`免费下载）。本CD-ROM是一个独立的产品，包含了一周“Hads-OnJava”培训课程的全部内容。这是一个由Bruce Eckel讲授的、长度在15小时以上的课程，含500张以上的演示幻灯片。该课程建立在这本书的基础上，所以是非常理想的一个配套产品。
 
 **CD-ROM包含了本书的两个版本：**
 
@@ -155,21 +157,19 @@ Java提供了一套内建的机制，可提供对多个并发子任务的支持
 
 (2) 为方便读者在屏幕上阅读和索引，CD-ROM提供了一个独特的超链接版本。这些超链接包括：
 
-```
-■230个章、节和小标题链接
++ 230个章、节和小标题链接
 
-■3600个索引链接
-```
++ 3600个索引链接
 
 CD-ROM刻录了600MB以上的数据。我相信它已对所谓“物超所值”进行了崭新的定义。
 
 CD-ROM包含了本书打印版的所有东西，另外还有来自五天快速入门课程的全部材料。我相信它建立了一个新的书刊品质评定标准。
 
-若想单独购买此CD-ROM，只能从Web站点www.BruceEckel.com处直接订购。
+若想单独购买此CD-ROM，只能从Web站点`www.BruceEckel.com`处直接订购。
 
 #### 8. 源代码
 
-本书所有源码都作为保留版权的免费软件提供，可以独立软件包的形式获得，亦可从http://www.BruceEckel.com下载。为保证大家获得的是最新版本，我用这个正式站点发行代码以及本书电子版。亦可在其他站点找到电子书和源码的镜像版（有些站点已在http://www.BruceEckel.com处列出）。但无论如何，都应检查正式站点，确定镜像版确实是最新的版本。可在课堂和其他教育场所发布这些代码。
+本书所有源码都作为保留版权的免费软件提供，可以独立软件包的形式获得，亦可从`http://www.BruceEckel.com`下载。为保证大家获得的是最新版本，我用这个正式站点发行代码以及本书电子版。亦可在其他站点找到电子书和源码的镜像版（有些站点已在`http://www.BruceEckel.com`处列出）。但无论如何，都应检查正式站点，确定镜像版确实是最新的版本。可在课堂和其他教育场所发布这些代码。
 
 版权的主要目标是保证源码得到正确的引用，并防止在未经许可的情况下，在印刷材料中发布代码。通常，只要源码获得了正确的引用，则在大多数媒体中使用本书的示例都没有什么问题。
 
@@ -187,9 +187,10 @@ CD-ROM包含了本书打印版的所有东西，另外还有来自五天快速
 
 对于本书的示例，我采用了一种特定的编码样式。该样式得到了大多数Java开发环境的支持。该样式问世已有几年的时间，最早起源于Bjarne Stroustrup先生在《The C++ Programming Language》里采用的样式（Addison-Wesley 1991年出版，第2版）。由于代码样式目前是个敏感问题，极易招致数小时的激烈辩论，所以我在这儿只想指出自己并不打算通过这些示例建立一种样式标准。之所以采用这些样式，完全出于我自己的考虑。由于Java是一种形式非常自由的编程语言，所以读者完全可以根据自己的感觉选用了适合的编码样式。
 
-本书的程序是由字处理程序包括在正文中的，它们直接取自编译好的文件。所以，本书印刷的代码文件应能正常工作，不会造成编译器错误。会造成编译错误的代码已经用注释//!标出。所以很容易发现，也很容易用自动方式进行测试。读者发现并向作者报告的错误首先会在发行的源码中改正，然后在本书的更新版中校订（所有更新都会在Web站点http://www.BruceEckel.com处出现）。
+本书的程序是由字处理程序包括在正文中的，它们直接取自编译好的文件。所以，本书印刷的代码文件应能正常工作，不会造成编译器错误。会造成编译错误的代码已经用注释//!标出。所以很容易发现，也很容易用自动方式进行测试。读者发现并向作者报告的错误首先会在发行的源码中改正，然后在本书的更新版中校订（所有更新都会在Web站点`http://www.BruceEckel.com`处出现）。
 
 #### 10. Java版本
+
 尽管我用几家厂商的Java开发平台对本书的代码进行了测试，但在判断代码行为是否正确时，却通常以Sun公司的Java开发平台为准。
 
 当您读到本书时，Sun应已发行了Java的三个重要版本：1.0，1.1及1.2（Sun声称每9个月就会发布一个主要更新版本）。就我看，1.1版对Java语言进行了显著改进，完全应标记成2.0版（由于1.1已作出了如此大的修改，真不敢想象2.0版会出现什么变化）。然而，它的1.2版看起来最终将Java推入了一个全盛时期，特别是其中考虑到了用户界面工具。
@@ -199,18 +200,19 @@ CD-ROM包含了本书打印版的所有东西，另外还有来自五天快速
 大家会注意到我并未使用子版本号，比如1.1.1。至本书完稿为止，Sun公司发布的最后一个1.0版是1.02；而1.1的最后版本是1.1.5（Java 1.2仍在做β测试）。在这本书中，我只会提到Java 1.0，Java 1.1及Java 1.2，避免由于子版本编号过多造成的键入和印刷错误。
 
 #### 11. 课程和培训
+
 我的公司提供了一个五日制的公共培训课程，以本书的内容为基础。每章的内容都代表着一堂课，并附有相应的课后练习，以便巩固学到的知识。一些辅助用的幻灯片可在本书的配套光盘上找到，最大限度地方便各位读者。欲了解更多的情况，请访问：
 
 http://www.BruceEckel.com
 
 或发函至：
 
-Bruce@EckelObjects.com
+<Bruce@EckelObjects.com>
 
 我的公司也提供了咨询服务，指导客户完成整个开发过程——特别是您的单位首次接触Java开发的时候。
 
 #### 12. 错误
-无论作者花多大精力来避免，错误总是从意想不到的地方冒出来。如果您认为自己发现了一个错误，请在源文件（可在 http://www.BruceEckel.com 处找到）里指出有可能是错误的地方，填好我们提供的表单。将您推荐的纠错方法通过电子函件发给Bruce@EckelObjects.com。经适当的核对与处理，Web站点的电子版以及本书的下一个印刷版本会作出相应的改正。具体格式如下：
+无论作者花多大精力来避免，错误总是从意想不到的地方冒出来。如果您认为自己发现了一个错误，请在源文件（可在 `http://www.BruceEckel.com` 处找到）里指出有可能是错误的地方，填好我们提供的表单。将您推荐的纠错方法通过电子函件发给`Bruce@EckelObjects.com`。经适当的核对与处理，Web站点的电子版以及本书的下一个印刷版本会作出相应的改正。具体格式如下：
 
 ```
 (1) 在主题行（Subject）写上“TIJ Correction”（去掉引号），以便您的函件进入对应的目录。
@@ -223,10 +225,11 @@ Comment: 在这里可写多行批注正文，最好以“here's how I think it s
 ###
 ```
 
-其中，“###”指出批注正文的结束。这样一来，我自己设计的一个纠错工具就能对原始正文来一次“搜索”，而您建议的纠错方法会在随后的一个窗口中弹出。
+其中，`###`指出批注正文的结束。这样一来，我自己设计的一个纠错工具就能对原始正文来一次“搜索”，而您建议的纠错方法会在随后的一个窗口中弹出。
 若希望在本书的下一版添加什么内容，或对书中的练习题有什么意见，也欢迎您指出。我们感谢您的所有意见。
 
 #### 13. 封面设计
+
 《Thinking in Java》一书封面的创作灵感来源于American Arts & CraftsMovement（美洲艺术＆手工艺品运动）。这一运动起始于世纪之交，1900到1920年达到了顶峰。它起源于英格兰，具有一定的历史背景。当时正是机器革命产生的风暴席卷整个大陆的时候，而且受到维多利亚地区强烈装饰风格的巨大影响。Arts&Crafts强调的是原始风格，回归自然的初衷是整个运动的核心。那时对手工制作推崇备至，手工艺人特别得到尊重。正因为如此，人们远远避开现代工具的使用。这场运动对整个艺术界造成了深远的影响，直至今天仍受到人们的怀念。特别是我们面临又一次世纪之交，强烈的怀旧情绪难免涌上心来。计算机发展至今，已走过了很长的一段路。我们更迫切地感到：软件设计中最重要的是设计者本身，而不是流水化的代码编制。如设计者本身的素质和修养不高，那么最多只是“生产”代码的工具而已。
 
 我以同样的眼光来看待Java：作为一种将程序员从操作系统繁琐机制中解放出来的尝试，它的目的是使人们成为真正的“软件艺术家”。
@@ -236,6 +239,7 @@ Comment: 在这里可写多行批注正文，最好以“here's how I think it s
 此外，封面向大家展示了一个收集箱，自然学者可能用它展示自己的昆虫标本。我们认为这些昆虫都是“对象”，全部置于更大的“收集箱”对象里，再统一置入“封面”这个对象里。它向我们揭示了面向对象编程技术最基本的“集合”概念。当然，作为一名程序员，大家对于“昆虫”或“虫”是非常敏感的（“虫”在英语里是Bug，后指程序错误）。这里的“虫”已被抓获，在一只广口瓶中杀死，最后禁闭于一个小的展览盒里——暗示Java有能力寻找、显示和消除程序里的“虫”（这是Java最具特色的特性之一）。
 
 #### 14. 致谢
+
 首先，感谢Doyle Street Cohousing Community（道尔街住房社区）容忍我花两年的时间来写这本书（其实他们一直都在容忍我的“胡做非为”）。非常感谢Kevin和Sonda Donovan，是他们把科罗拉多Crested Butte市这个风景优美的地方租给我，使我整个夏天都能安心写作。感谢Crested Butte友好的居民；以及Rocky Mountain Biological Laboratory（岩石山生物实验室），他们的工作人员总是面带微笑。
 
 这是我第一次找代理人出书，但却绝没有后悔。谢谢“摩尔文学代理公司”的Claudette Moore小姐。是她强大的信心与毅力使我最终梦想成真。
@@ -248,7 +252,7 @@ Comment: 在这里可写多行批注正文，最好以“here's how I think it s
 
 感谢那些在“Java软件开发会议”上我的Java小组发言的同志们，以及我教授过的那些学生，他们提出的问题使我的教案愈发成熟起来。
 
-特别感谢Larry和Tina O'Brien，是他们将这本书和我的教学内容制成一张教学CD-ROM（关于这方面的问题，http://www.BruceEckel.com有更多的答案）。
+特别感谢Larry和Tina O'Brien，是他们将这本书和我的教学内容制成一张教学CD-ROM（关于这方面的问题，`http://www.BruceEckel.com`有更多的答案）。
 
 有许多人送来了纠错报告，我真的很感激所有这些朋友，但特别要对下面这些人说声谢谢：Kevin Raulerson（发现了多处重大错误），Bob Resendes（发现的错误令人难以置信），John Pinto，Joe Dante，Joe Sharp，David Combs（许多语法和表达不清的地方），Dr. Robert Stephenson，Franklin Chen，Zev Griner，David Karr，Leander A. Stroschein，Steve Clark，Charles A. Lee，AustinMaher，Dennis P. Roth，Roque Oliveira，Douglas Dunn，Dejan Ristic，NeilGalarneau，David B. Malkovsky，Steve Wilkinson，以及其他许多热心读者。
 
@@ -259,9 +263,9 @@ Comment: 在这里可写多行批注正文，最好以“here's how I think it s
 
 我的朋友Richard Hale Shaw（以及Kim）的一些意见和支持发挥了非常关键的作用。Richard和我花了数月的时间将教学内容合并到一起，并探讨如何使学生感受到最完美的学习体验。也要感谢KoAnn Vikoren，Eric Eaurot，DeborahSommers，Julie Shaw，Nicole Freeman，Cindy Blair，Barbara Hanscome，Regina Ridley，Alex Dunne以及MFI其他可敬的成员。
 
-书籍设计、封面设计以及封面照片是由我的朋友Daniel Will-Harris制作的。他是一位著名的作家和设计家（http://www.WillHarris.com），在初中的时候就已显露出了过人的数学天赋。但是，小样是由我制作的，所以录入错误都是我的。我是用Microsoft Word 97 for Windows来写这本书，并用它生成小样。正文字体采用的是Bitstream Carmina；标题采用Bitstream Calligraph 421（www.bitstream.com）；每章开头的符号采用的是来自P22的Leonardo Extras（http://www.p22.com）；封面字体采用ITC Rennie Marckintosh。
+书籍设计、封面设计以及封面照片是由我的朋友Daniel Will-Harris制作的。他是一位著名的作家和设计家（`http://www.WillHarris.com`），在初中的时候就已显露出了过人的数学天赋。但是，小样是由我制作的，所以录入错误都是我的。我是用Microsoft Word 97 for Windows来写这本书，并用它生成小样。正文字体采用的是Bitstream Carmina；标题采用Bitstream Calligraph 421（`www.bitstream.com`）；每章开头的符号采用的是来自P22的Leonardo Extras（`http://www.p22.com`）；封面字体采用ITC Rennie Marckintosh。
 感谢为我提供编译器程序的一些著名公司：Borland，Microsoft，Symantec，Sybase/Powersoft/Watcom以及Sun。
 
 特别感谢我的老师和我所有的学生（他们也是我的老师），其中最有趣的一位写作老师是Gabrielle Rico（《Writing the Natural Way》一书的作者，Putnam于1983年出版）。
 
-曾向我提供过支持的朋友包括（当然还不止）：Andrew Binstock，SteveSinofsky，JD Hildebrandt，Tom Keffer，Brian McElhinney，Brinkley Barr，《Midnight Engineering》杂志社的Bill Gates，Larry Constantine和LucyLockwood，Greg Perry，Dan Putterman，Christi Westphal，Gene Wang，DaveMayer，David Intersimone，Andrea Rosenfield，Claire Sawyers，另一些意大利朋友（Laura Fallai，Corrado，Ilsa和Cristina Giustozzi），Chris和Laura Strand，Almquists，Brad Jerbic，Marilyng Cvitanic，Mabrys，Haflingers，Pollocks，Peter Vinci，Robbins Families，Moelter Families（和McMillans），Michael Wilk，Dave Stoner，Laurie Adams，Cranstons，Larry Fogg，Mike和Karen Sequeira，Gary Entsminger和Allison Brody，KevinDonovan和Sonda Eastlack，Chester和Shannon Andersen，Joe Lordi，Dave和Brenda Bartlett，David Lee，Rentschlers，Sudeks，Dick，Patty和Lee Eckel，Lynn和Todd以及他们的家人。最后，当然还有我的爸爸和妈妈。
+曾向我提供过支持的朋友包括（当然还不止）：Andrew Binstock，SteveSinofsky，JD Hildebrandt，Tom Keffer，Brian McElhinney，Brinkley Barr，《Midnight Engineering》杂志社的Bill Gates，Larry Constantine和LucyLockwood，Greg Perry，Dan Putterman，Christi Westphal，Gene Wang，DaveMayer，David Intersimone，Andrea Rosenfield，Claire Sawyers，另一些意大利朋友（Laura Fallai，Corrado，Ilsa和Cristina Giustozzi），Chris和Laura Strand，Almquists，Brad Jerbic，Marilyng Cvitanic，Mabrys，Haflingers，Pollocks，Peter Vinci，Robbins Families，Moelter Families（和McMillans），Michael Wilk，Dave Stoner，Laurie Adams，Cranstons，Larry Fogg，Mike和Karen Sequeira，Gary Entsminger和Allison Brody，KevinDonovan和Sonda Eastlack，Chester和Shannon Andersen，Joe Lordi，Dave和Brenda Bartlett，David Lee，Rentschlers，Sudeks，Dick，Patty和Lee Eckel，Lynn和Todd以及他们的家人。最后，当然还有我的爸爸和妈妈。
\ No newline at end of file

第13章 创建窗口和程序片.md

 # 第13章 创建窗口和程序片
 
-> ps：本章应用少，暂时不编辑格式，请跳过本章节
-
 在Java 1.0中，图形用户接口（GUI）库最初的设计目标是让程序员构建一个通用的GUI，使其在所有平台上都能正常显示。
+
 但遗憾的是，这个目标并未达到。事实上，Java 1.0版的“抽象Windows工具包”（AWT）产生的是在各系统看来都同样欠佳的图形用户接口。除此之外，它还限制我们只能使用四种字体，并且不能访问操作系统中现有的高级GUI元素。同时，Jave1.0版的AWT编程模型也不是面向对象的，极不成熟。这类情况在Java1.1版的AWT事件模型中得到了很好的改进，例如：更加清晰、面向对象的编程、遵循Java Beans的范例，以及一个可轻松创建可视编程环境的编程组件模型。Java1.2为老的Java 1.0 AWT添加了Java基类（AWT），这是一个被称为“Swing”的GUI的一部分。丰富的、易于使用和理解的Java Beans能经过拖放操作（像手工编程一样的好），创建出能使程序员满意的GUI。软件业的“3次修订版”规则看来对于程序设计语言也是成立的（一个产品除非经过第3次修订，否则不会尽如人意）。
 Java的主要设计目的之一是建立程序片，也就是建立运行在WEB 浏览器上的小应用程序。由于它们必须是安全的，所以程序片在运行时必须加以限制。无论怎样，它们都是支持客户端编程的强有力的工具，一个重要的应用便是在Web上。
 在一个程序片中编程会受到很多的限制，我们一般说它“在沙箱内”，这是由于Java运行时一直会有某个东西——即Java运行期安全系统——在监视着我们。Jave 1.1为程序片提供了数字签名，所以可选出能信赖的程序片去访问主机。不过，我们也能跳出沙箱的限制写出可靠的程序。在这种情况下，我们可访问操作系统中的其他功能。在这本书中我们自始至终编写的都是可靠的程序，但它们成为了没有图形组件的控制台程序。AWT也能用来为可靠的程序建立GUI接口。
@@ -132,7 +131,7 @@ public class Applet3 extends Applet {
   public void start() { starts++; }
   public void stop() { stops++; }
   public void paint(Graphics g) {
-    s = "inits: " + inits + 
+    s = "inits: " + inits +
       ", starts: " + starts +
       ", stops: " + stops;
     g.drawString(s, 10, 10);
@@ -151,8 +150,8 @@ import java.awt.*;
 import java.applet.*;
 
 public class Button1 extends Applet {
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public void init() {
     add(b1);
@@ -177,8 +176,8 @@ import java.awt.*;
 import java.applet.*;
 
 public class Button2 extends Applet {
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public void init() {
     add(b1);
@@ -190,7 +189,7 @@ public class Button2 extends Applet {
     else if(evt.target.equals(b2))
       getAppletContext().showStatus("Button 2");
     // Let the base class handle it:
-    else 
+    else
       return super.action(evt, arg);
     return true; // We've handled it here
   }
@@ -208,8 +207,8 @@ import java.awt.*;
 import java.applet.*;
 
 public class Button3 extends Applet {
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public void init() {
     add(b1);
@@ -221,7 +220,7 @@ public class Button3 extends Applet {
     else if(arg.equals("Button 2"))
       getAppletContext().showStatus("Button 2");
     // Let the base class handle it:
-    else 
+    else
       return super.action(evt, arg);
     return true; // We've handled it here
   }
@@ -240,7 +239,7 @@ public class TextField1 extends Applet {
   Button
     b1 = new Button("Get Text"),
     b2 = new Button("Set Text");
-  TextField 
+  TextField
     t = new TextField("Starting text", 30);
   String s = new String();
   public void init() {
@@ -260,7 +259,7 @@ public class TextField1 extends Applet {
       t.setEditable(false);
     }
     // Let the base class handle it:
-    else 
+    else
       return super.action(evt, arg);
     return true; // We've handled it here
   }
@@ -306,7 +305,7 @@ public class TextArea1 extends Applet {
     else if(evt.target.equals(b4))
       t2.insertText(" Inserted ", 10);
     // Let the base class handle it:
-    else 
+    else
       return super.action(evt, arg);
     return true; // We've handled it here
   }
@@ -348,7 +347,7 @@ public class Label1 extends Applet {
       else if(labl3.getAlignment() == Label.RIGHT)
         labl3.setAlignment(Label.LEFT);
     }
-    else 
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -383,7 +382,7 @@ public class CheckBox1 extends Applet {
       trace("2", cb2.getState());
     else if(evt.target.equals(cb3))
       trace("3", cb3.getState());
-    else 
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -408,17 +407,17 @@ import java.awt.*;
 import java.applet.*;
 
 public class RadioButton1 extends Applet {
-  TextField t = 
+  TextField t =
     new TextField("Radio button 2", 30);
   CheckboxGroup g = new CheckboxGroup();
-  Checkbox 
+  Checkbox
     cb1 = new Checkbox("one", g, false),
     cb2 = new Checkbox("two", g, true),
     cb3 = new Checkbox("three", g, false);
   public void init() {
     t.setEditable(false);
-    add(t); 
-    add(cb1); add(cb2); add(cb3); 
+    add(t);
+    add(cb1); add(cb2); add(cb3);
   }
   public boolean action (Event evt, Object arg) {
     if(evt.target.equals(cb1))
@@ -427,7 +426,7 @@ public class RadioButton1 extends Applet {
       t.setText("Radio button 2");
     else if(evt.target.equals(cb3))
       t.setText("Radio button 3");
-    else 
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -466,8 +465,8 @@ public class Choice1 extends Applet {
     else if(evt.target.equals(b)) {
       if(count < description.length)
         c.addItem(description[count++]);
-    } 
-    else 
+    }
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -487,8 +486,8 @@ import java.applet.*;
 
 public class List1 extends Applet {
   String[] flavors = { "Chocolate", "Strawberry",
-    "Vanilla Fudge Swirl", "Mint Chip", 
-    "Mocha Almond Fudge", "Rum Raisin", 
+    "Vanilla Fudge Swirl", "Mint Chip",
+    "Mocha Almond Fudge", "Rum Raisin",
     "Praline Cream", "Mud Pie" };
   // Show 6 items, allow multiple selection:
   List lst = new List(6, true);
@@ -514,7 +513,7 @@ public class List1 extends Applet {
       if(count < flavors.length)
         lst.addItem(flavors[count++], 0);
     }
-    else 
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -534,8 +533,8 @@ import java.applet.*;
 
 public class List2 extends Applet {
   String[] flavors = { "Chocolate", "Strawberry",
-    "Vanilla Fudge Swirl", "Mint Chip", 
-    "Mocha Almond Fudge", "Rum Raisin", 
+    "Vanilla Fudge Swirl", "Mint Chip",
+    "Mocha Almond Fudge", "Rum Raisin",
     "Praline Cream", "Mud Pie" };
   // Show 6 items, allow multiple selection:
   List lst = new List(6, true);
@@ -559,10 +558,10 @@ public class List2 extends Applet {
         for(int i = 0; i < items.length; i++)
           t.appendText(items[i] + "\n");
       }
-      else 
+      else
         return super.handleEvent(evt);
-    } 
-    else 
+    }
+    else
       return super.handleEvent(evt);
     return true;
   }
@@ -571,7 +570,7 @@ public class List2 extends Applet {
       if(count < flavors.length)
         lst.addItem(flavors[count++], 0);
     }
-    else 
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -676,26 +675,26 @@ public class CardLayout1 extends Applet {
     p.add(third);
     add("North", p);
     cards.setLayout(cl);
-    cards.add("First card", 
+    cards.add("First card",
       new ButtonPanel("The first one"));
-    cards.add("Second card", 
+    cards.add("Second card",
       new ButtonPanel("The second one"));
-    cards.add("Third card", 
+    cards.add("Third card",
       new ButtonPanel("The third one"));
     add("Center", cards);
   }
   public boolean action(Event evt, Object arg) {
     if (evt.target.equals(first)) {
       cl.first(cards);
-    } 
+    }
     else if (evt.target.equals(second)) {
       cl.first(cards);
       cl.next(cards);
-    } 
+    }
     else if (evt.target.equals(third)) {
       cl.last(cards);
-    } 
-    else 
+    }
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -741,7 +740,7 @@ class MyButton extends Canvas {
   AutoEvent parent;
   Color color;
   String label;
-  MyButton(AutoEvent parent, 
+  MyButton(AutoEvent parent,
            Color color, String label) {
     this.label = label;
     this.parent = parent;
@@ -750,10 +749,10 @@ class MyButton extends Canvas {
   public void paint(Graphics  g) {
     g.setColor(color);
     int rnd = 30;
-    g.fillRoundRect(0, 0, size().width, 
+    g.fillRoundRect(0, 0, size().width,
                     size().height, rnd, rnd);
     g.setColor(Color.black);
-    g.drawRoundRect(0, 0, size().width, 
+    g.drawRoundRect(0, 0, size().width,
                     size().height, rnd, rnd);
     FontMetrics fm = g.getFontMetrics();
     int width = fm.stringWidth(label);
@@ -763,70 +762,70 @@ class MyButton extends Canvas {
     int horizMargin = (size().width - width)/2;
     int verMargin = (size().height - height)/2;
     g.setColor(Color.white);
-    g.drawString(label, horizMargin, 
+    g.drawString(label, horizMargin,
                  verMargin + ascent + leading);
   }
   public boolean keyDown(Event evt, int key) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("keyDown");
     t.setText(evt.toString());
     return true;
   }
   public boolean keyUp(Event evt, int key) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("keyUp");
     t.setText(evt.toString());
     return true;
   }
   public boolean lostFocus(Event evt, Object w) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("lostFocus");
     t.setText(evt.toString());
     return true;
   }
   public boolean gotFocus(Event evt, Object w) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("gotFocus");
     t.setText(evt.toString());
     return true;
   }
-  public boolean 
+  public boolean
   mouseDown(Event evt,int x,int y) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("mouseDown");
     t.setText(evt.toString());
     return true;
   }
-  public boolean 
+  public boolean
   mouseDrag(Event evt,int x,int y) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("mouseDrag");
     t.setText(evt.toString());
     return true;
   }
-  public boolean 
+  public boolean
   mouseEnter(Event evt,int x,int y) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("mouseEnter");
     t.setText(evt.toString());
     return true;
   }
-  public boolean 
+  public boolean
   mouseExit(Event evt,int x,int y) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("mouseExit");
     t.setText(evt.toString());
     return true;
   }
-  public boolean 
+  public boolean
   mouseMove(Event evt,int x,int y) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("mouseMove");
     t.setText(evt.toString());
     return true;
   }
   public boolean mouseUp(Event evt,int x,int y) {
-    TextField t = 
+    TextField t =
       (TextField)parent.h.get("mouseUp");
     t.setText(evt.toString());
     return true;
@@ -836,12 +835,12 @@ class MyButton extends Canvas {
 public class AutoEvent extends Applet {
   Hashtable h = new Hashtable();
   String[] event = {
-    "keyDown", "keyUp", "lostFocus", 
-    "gotFocus", "mouseDown", "mouseUp", 
-    "mouseMove", "mouseDrag", "mouseEnter", 
+    "keyDown", "keyUp", "lostFocus",
+    "gotFocus", "mouseDown", "mouseUp",
+    "mouseMove", "mouseDrag", "mouseEnter",
     "mouseExit"
   };
-  MyButton 
+  MyButton
     b1 = new MyButton(this, Color.blue, "test1"),
     b2 = new MyButton(this, Color.red, "test2");
   public void init() {
@@ -849,7 +848,7 @@ public class AutoEvent extends Applet {
     for(int i = 0; i < event.length; i++) {
       TextField t = new TextField();
       t.setEditable(false);
-      add(new Label(event[i], Label.CENTER)); 
+      add(new Label(event[i], Label.CENTER));
       add(t);
       h.put(event[i], t);
     }
@@ -897,8 +896,8 @@ import java.awt.*;
 
 public class Menu1 extends Frame {
   String[] flavors = { "Chocolate", "Strawberry",
-    "Vanilla Fudge Swirl", "Mint Chip", 
-    "Mocha Almond Fudge", "Rum Raisin", 
+    "Vanilla Fudge Swirl", "Mint Chip",
+    "Mocha Almond Fudge", "Rum Raisin",
     "Praline Cream", "Mud Pie" };
   TextField t = new TextField("No flavor", 30);
   MenuBar mb1 = new MenuBar();
@@ -927,7 +926,7 @@ public class Menu1 extends Frame {
     for(int i = 0; i < flavors.length; i++) {
       m.add(new MenuItem(flavors[i]));
       // Add separators at intervals:
-      if((i+1) % 3 == 0) 
+      if((i+1) % 3 == 0)
         m.addSeparator();
     }
     for(int i = 0; i < safety.length; i++)
@@ -947,9 +946,9 @@ public class Menu1 extends Frame {
     mb2.add(fooBar);
   }
   public boolean handleEvent(Event evt) {
-    if(evt.id == Event.WINDOW_DESTROY) 
+    if(evt.id == Event.WINDOW_DESTROY)
       System.exit(0);
-    else 
+    else
       return super.handleEvent(evt);
     return true;
   }
@@ -958,7 +957,7 @@ public class Menu1 extends Frame {
       MenuBar m = getMenuBar();
       if(m == mb1) setMenuBar(mb2);
       else if (m == mb2) setMenuBar(mb1);
-    } 
+    }
     else if(evt.target instanceof MenuItem) {
       if(arg.equals("Open")) {
         String s = t.getText();
@@ -972,7 +971,7 @@ public class Menu1 extends Frame {
       }
       else if(evt.target.equals(file[1]))
         System.exit(0);
-      // CheckboxMenuItems cannot use String 
+      // CheckboxMenuItems cannot use String
       // matching; you must match the target:
       else if(evt.target.equals(safety[0]))
         t.setText("Guard the Ice Cream! " +
@@ -980,10 +979,10 @@ public class Menu1 extends Frame {
       else if(evt.target.equals(safety[1]))
         t.setText("Hide the Ice Cream! " +
           "Is it cold? " + safety[1].getState());
-      else 
+      else
         t.setText(arg.toString());
-    } 
-    else 
+    }
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -1034,15 +1033,15 @@ class ToeButton extends Canvas {
       g.drawOval(x1, y1, x1+wide/2, y1+high/2);
     }
   }
-  public boolean 
+  public boolean
   mouseDown(Event evt, int x, int y) {
     if(state == ToeDialog.BLANK) {
       state = parent.turn;
       parent.turn= (parent.turn == ToeDialog.XX ?
         ToeDialog.OO : ToeDialog.XX);
-    } 
+    }
     else
-      state = (state == ToeDialog.XX ? 
+      state = (state == ToeDialog.XX ?
         ToeDialog.OO : ToeDialog.XX);
     repaint();
     return true;
@@ -1064,9 +1063,9 @@ class ToeDialog extends Dialog {
     resize(w * 50, h * 50);
   }
   public boolean handleEvent(Event evt) {
-    if(evt.id == Event.WINDOW_DESTROY) 
+    if(evt.id == Event.WINDOW_DESTROY)
       dispose();
-    else 
+    else
       return super.handleEvent(evt);
     return true;
   }
@@ -1087,21 +1086,21 @@ public class ToeTest extends Frame {
     add("South", new Button("go"));
   }
   public boolean handleEvent(Event evt) {
-    if(evt.id == Event.WINDOW_DESTROY) 
+    if(evt.id == Event.WINDOW_DESTROY)
       System.exit(0);
-    else 
+    else
       return super.handleEvent(evt);
     return true;
   }
   public boolean action(Event evt, Object arg) {
     if(arg.equals("go")) {
       Dialog d = new ToeDialog(
-        this, 
+        this,
         Integer.parseInt(rows.getText()),
         Integer.parseInt(cols.getText()));
       d.show();
-    } 
-    else 
+    }
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -1147,9 +1146,9 @@ public class FileDialogTest extends Frame {
     add("North", p);
   }
   public boolean handleEvent(Event evt) {
-    if(evt.id == Event.WINDOW_DESTROY) 
+    if(evt.id == Event.WINDOW_DESTROY)
       System.exit(0);
-    else 
+    else
       return super.handleEvent(evt);
     return true;
   }
@@ -1169,7 +1168,7 @@ public class FileDialogTest extends Frame {
         filename.setText("You pressed cancel");
         directory.setText("");
       }
-    } 
+    }
     else if(evt.target.equals(save)) {
       FileDialog d = new FileDialog(this,
         "What file do you want to save?",
@@ -1185,8 +1184,8 @@ public class FileDialogTest extends Frame {
         filename.setText("You pressed cancel");
         directory.setText("");
       }
-    } 
-    else 
+    }
+    else
       return super.action(evt, arg);
     return true;
   }
@@ -1245,7 +1244,7 @@ public class Button2New extends Applet {
     else if(evt.target.equals(b2))
       getAppletContext().showStatus("Button 2");
     // Let the base class handle it:
-    else 
+    else
       return super.action(evt, arg);
     return true; // We've handled it here
   }
@@ -1519,11 +1518,11 @@ WindowListener
 WindowAdapter
 
 windowOpened(WindowEvent)
-windowClosing(WindowEvent) 
-windowClosed(WindowEvent) 
-windowActivated(WindowEvent) 
-windowDeactivated(WindowEvent) 
-windowIconified(WindowEvent) 
+windowClosing(WindowEvent)
+windowClosed(WindowEvent)
+windowActivated(WindowEvent)
+windowDeactivated(WindowEvent)
+windowIconified(WindowEvent)
 windowDeiconified(WindowEvent)
 
 ItemListener
@@ -1636,8 +1635,8 @@ jar cf Button2NewB.jar *.class
 <head><title>Button2NewB Example Applet
 </title></head>
 <body>
-<applet code="Button2NewB.class" 
-        archive="Button2NewB.jar" 
+<applet code="Button2NewB.class"
+        archive="Button2NewB.jar"
         width=200 height=150>
 </applet>
 </body>
@@ -1656,10 +1655,10 @@ import java.awt.event.*;
 import java.applet.*;
 
 public class TextNew extends Applet {
-  Button 
-    b1 = new Button("Get Text"), 
+  Button
+    b1 = new Button("Get Text"),
     b2 = new Button("Set Text");
-  TextField 
+  TextField
     t1 = new TextField(30),
     t2 = new TextField(30),
     t3 = new TextField(30);
@@ -1690,14 +1689,14 @@ public class TextNew extends Applet {
   class T1K extends KeyAdapter {
     public void keyTyped(KeyEvent e) {
       String ts = t1.getText();
-      if(e.getKeyChar() == 
+      if(e.getKeyChar() ==
           KeyEvent.VK_BACK_SPACE) {
         // Ensure it's not empty:
         if( ts.length() > 0) {
           ts = ts.substring(0, ts.length() - 1);
           t1.setText(ts);
         }
-      } 
+      }
       else
         t1.setText(
           t1.getText() +
@@ -1706,7 +1705,7 @@ public class TextNew extends Applet {
       t1.setCaretPosition(
         t1.getText().length());
       // Stop regular character from appearing:
-      e.consume(); 
+      e.consume();
     }
   }
   class B1 implements ActionListener {
@@ -1848,13 +1847,13 @@ public class RadioCheckNew extends Applet {
     new Checkbox("Check Box 2"),
     new Checkbox("Check Box 3") };
   CheckboxGroup g = new CheckboxGroup();
-  Checkbox 
+  Checkbox
     cb4 = new Checkbox("four", g, false),
     cb5 = new Checkbox("five", g, true),
     cb6 = new Checkbox("six", g, false);
   public void init() {
     t.setEditable(false);
-    add(t); 
+    add(t);
     ILCheck il = new ILCheck();
     for(int i = 0; i < cb.length; i++) {
       cb[i].addItemListener(il);
@@ -1863,7 +1862,7 @@ public class RadioCheckNew extends Applet {
     cb4.addItemListener(new IL4());
     cb5.addItemListener(new IL5());
     cb6.addItemListener(new IL6());
-    add(cb4); add(cb5); add(cb6); 
+    add(cb4); add(cb5); add(cb6);
   }
   // Checking the source:
   class ILCheck implements ItemListener {
@@ -1978,8 +1977,8 @@ import java.applet.*;
 
 public class ListNew extends Applet {
   String[] flavors = { "Chocolate", "Strawberry",
-    "Vanilla Fudge Swirl", "Mint Chip", 
-    "Mocha Almond Fudge", "Rum Raisin", 
+    "Vanilla Fudge Swirl", "Mint Chip",
+    "Mocha Almond Fudge", "Rum Raisin",
     "Praline Cream", "Mud Pie" };
   // Show 6 items, allow multiple selection:
   List lst = new List(6, true);
@@ -2038,8 +2037,8 @@ import java.awt.event.*;
 
 public class MenuNew extends Frame {
   String[] flavors = { "Chocolate", "Strawberry",
-    "Vanilla Fudge Swirl", "Mint Chip", 
-    "Mocha Almond Fudge", "Rum Raisin", 
+    "Vanilla Fudge Swirl", "Mint Chip",
+    "Mocha Almond Fudge", "Rum Raisin",
     "Praline Cream", "Mud Pie" };
   TextField t = new TextField("No flavor", 30);
   MenuBar mb1 = new MenuBar();
@@ -2055,7 +2054,7 @@ public class MenuNew extends Frame {
     // No menu shortcut:
     new MenuItem("Open"),
     // Adding a menu shortcut is very simple:
-    new MenuItem("Exit", 
+    new MenuItem("Exit",
       new MenuShortcut(KeyEvent.VK_E))
   };
   // A second menu bar to swap to:
@@ -2090,7 +2089,7 @@ public class MenuNew extends Frame {
       mi.addActionListener(fl);
       m.add(mi);
       // Add separators at intervals:
-      if((i+1) % 3 == 0) 
+      if((i+1) % 3 == 0)
         m.addSeparator();
     }
     for(int i = 0; i < safety.length; i++)
@@ -2120,7 +2119,7 @@ public class MenuNew extends Frame {
   class ML implements ActionListener {
     public void actionPerformed(ActionEvent e) {
       MenuItem target = (MenuItem)e.getSource();
-      String actionCommand = 
+      String actionCommand =
         target.getActionCommand();
       if(actionCommand.equals("Open")) {
         String s = t.getText();
@@ -2133,7 +2132,7 @@ public class MenuNew extends Frame {
           t.setText("Opening "+ s +". Mmm, mm!");
       } else if(actionCommand.equals("Exit")) {
         dispatchEvent(
-          new WindowEvent(MenuNew.this, 
+          new WindowEvent(MenuNew.this,
             WindowEvent.WINDOW_CLOSING));
       }
     }
@@ -2164,9 +2163,9 @@ public class MenuNew extends Frame {
   }
   class CMIL implements ItemListener {
     public void itemStateChanged(ItemEvent e) {
-      CheckboxMenuItem target = 
+      CheckboxMenuItem target =
         (CheckboxMenuItem)e.getSource();
-      String actionCommand = 
+      String actionCommand =
         target.getActionCommand();
       if(actionCommand.equals("Guard"))
         t.setText("Guard the Ice Cream! " +
@@ -2228,7 +2227,7 @@ public class ToeTestNew extends Frame {
     // h = number of cells high
     int turn = XX; // Start with x's turn
     public ToeDialog(int w, int h) {
-      super(ToeTestNew.this, 
+      super(ToeTestNew.this,
         "The game itself", false);
       setLayout(new GridLayout(w, h));
       for(int i = 0; i < w * h; i++)
@@ -2256,13 +2255,13 @@ public class ToeTestNew extends Frame {
         int wide = x2/2;
         int high = y2/2;
         if(state == XX) {
-          g.drawLine(x1, y1, 
+          g.drawLine(x1, y1,
             x1 + wide, y1 + high);
-          g.drawLine(x1, y1 + high, 
+          g.drawLine(x1, y1 + high,
             x1 + wide, y1);
         }
         if(state == OO) {
-          g.drawOval(x1, y1, 
+          g.drawOval(x1, y1,
             x1 + wide/2, y1 + high/2);
         }
       }
@@ -2271,7 +2270,7 @@ public class ToeTestNew extends Frame {
           if(state == BLANK) {
             state = turn;
             turn = (turn == XX ? OO : XX);
-          } 
+          }
           else
             state = (state == XX ? OO : XX);
           repaint();
@@ -2397,8 +2396,8 @@ import java.util.*;
 public class DynamicEvents extends Frame {
   Vector v = new Vector();
   int i = 0;
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public DynamicEvents() {
     setLayout(new FlowLayout());
@@ -2492,7 +2491,7 @@ class BusinessLogic {
 }
 
 public class Separation extends Applet {
-  TextField 
+  TextField
     t = new TextField(20),
     mod = new TextField(20);
   BusinessLogic bl = new BusinessLogic(2);
@@ -2561,15 +2560,15 @@ public class Separation extends Applet {
 //: GoodIdea.java
 // The best way to design classes using the new
 // Java 1.1 event model: use an inner class for
-// each different event. This maximizes 
+// each different event. This maximizes
 // flexibility and modularity.
 import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
 
 public class GoodIdea extends Frame {
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public GoodIdea() {
     setLayout(new FlowLayout());
@@ -2615,10 +2614,10 @@ import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
 
-public class BadIdea1 extends Frame 
+public class BadIdea1 extends Frame
     implements ActionListener, WindowListener {
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public BadIdea1() {
     setLayout(new FlowLayout());
@@ -2667,7 +2666,7 @@ b2.addActionListener(this);
 第二个bad idea混合了两种方法：使用内嵌接收器类，但同样执行一个或更多的接收器接口以作为主类的一部分。这种方法无需在书中和文件中进行解释，而且我可以臆测到Java开发者认为他们必须为不同的目的而采取不同的方法。但我们却不必——在我们编程时，我们或许可能会倾向于使用内嵌接收器类。
 //: BadIdea2.java
 // An improvement over BadIdea1.java, since it
-// uses the WindowAdapter as an inner class 
+// uses the WindowAdapter as an inner class
 // instead of implementing all the methods of
 // WindowListener, but still misses the
 // valuable modularity of inner classes
@@ -2675,10 +2674,10 @@ import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
 
-public class BadIdea2 extends Frame 
+public class BadIdea2 extends Frame
     implements ActionListener {
-  Button 
-    b1 = new Button("Button 1"), 
+  Button
+    b1 = new Button("Button 1"),
     b2 = new Button("Button 2");
   public BadIdea2() {
     setLayout(new FlowLayout());
@@ -2773,59 +2772,59 @@ class EnabledPanel extends Panel {
   }
   class CL implements ComponentListener {
     public void componentMoved(ComponentEvent e){
-      display.evnt[Display.COMPONENT] = 
+      display.evnt[Display.COMPONENT] =
         "Component moved";
       repaint();
     }
-    public void 
+    public void
     componentResized(ComponentEvent e) {
-      display.evnt[Display.COMPONENT] = 
+      display.evnt[Display.COMPONENT] =
         "Component resized";
       repaint();
     }
-    public void 
+    public void
     componentHidden(ComponentEvent e) {
-      display.evnt[Display.COMPONENT] = 
+      display.evnt[Display.COMPONENT] =
         "Component hidden";
       repaint();
     }
     public void componentShown(ComponentEvent e){
-      display.evnt[Display.COMPONENT] = 
+      display.evnt[Display.COMPONENT] =
         "Component shown";
       repaint();
     }
   }
   class FL implements FocusListener {
     public void focusGained(FocusEvent e) {
-      display.evnt[Display.FOCUS] = 
+      display.evnt[Display.FOCUS] =
         "FOCUS gained";
       repaint();
     }
     public void focusLost(FocusEvent e) {
-      display.evnt[Display.FOCUS] = 
+      display.evnt[Display.FOCUS] =
         "FOCUS lost";
       repaint();
     }
   }
   class KL implements KeyListener {
     public void keyPressed(KeyEvent e) {
-      display.evnt[Display.KEY] = 
-        "KEY pressed: "; 
+      display.evnt[Display.KEY] =
+        "KEY pressed: ";
       showCode(e);
     }
     public void keyReleased(KeyEvent e) {
-      display.evnt[Display.KEY] = 
-        "KEY released: "; 
+      display.evnt[Display.KEY] =
+        "KEY released: ";
       showCode(e);
     }
     public void keyTyped(KeyEvent e) {
-      display.evnt[Display.KEY] = 
+      display.evnt[Display.KEY] =
         "KEY typed: ";
       showCode(e);
     }
     void showCode(KeyEvent e) {
       int code = e.getKeyCode();
-      display.evnt[Display.KEY] += 
+      display.evnt[Display.KEY] +=
         KeyEvent.getKeyText(code);
       repaint();
     }
@@ -2833,51 +2832,51 @@ class EnabledPanel extends Panel {
   class ML implements MouseListener {
     public void mouseClicked(MouseEvent e) {
       requestFocus(); // Get FOCUS on click
-      display.evnt[Display.MOUSE] = 
+      display.evnt[Display.MOUSE] =
         "MOUSE clicked";
       showMouse(e);
     }
     public void mousePressed(MouseEvent e) {
-      display.evnt[Display.MOUSE] = 
+      display.evnt[Display.MOUSE] =
         "MOUSE pressed";
       showMouse(e);
     }
     public void mouseReleased(MouseEvent e) {
-      display.evnt[Display.MOUSE] = 
+      display.evnt[Display.MOUSE] =
         "MOUSE released";
       showMouse(e);
     }
-    public void mouseEntered(MouseEvent e) { 
-      display.evnt[Display.MOUSE] = 
+    public void mouseEntered(MouseEvent e) {
+      display.evnt[Display.MOUSE] =
         "MOUSE entered";
       showMouse(e);
     }
-    public void mouseExited(MouseEvent e) { 
-      display.evnt[Display.MOUSE] = 
+    public void mouseExited(MouseEvent e) {
+      display.evnt[Display.MOUSE] =
         "MOUSE exited";
       showMouse(e);
     }
     void showMouse(MouseEvent e) {
-      display.evnt[Display.MOUSE] += 
-        ", x = " + e.getX() + 
+      display.evnt[Display.MOUSE] +=
+        ", x = " + e.getX() +
         ", y = " + e.getY();
       repaint();
     }
   }
   class MML implements MouseMotionListener {
     public void mouseDragged(MouseEvent e) {
-      display.evnt[Display.MOUSE_MOVE] = 
+      display.evnt[Display.MOUSE_MOVE] =
         "MOUSE dragged";
       showMouse(e);
     }
     public void mouseMoved(MouseEvent e) {
-      display.evnt[Display.MOUSE_MOVE] = 
+      display.evnt[Display.MOUSE_MOVE] =
         "MOUSE moved";
       showMouse(e);
     }
     void showMouse(MouseEvent e) {
-      display.evnt[Display.MOUSE_MOVE] += 
-        ", x = " + e.getX() + 
+      display.evnt[Display.MOUSE_MOVE] +=
+        ", x = " + e.getX() +
         ", y = " + e.getY();
       repaint();
     }
@@ -2904,12 +2903,12 @@ class MyButton extends Button {
     int height = fm.getHeight();
     int ascent = fm.getAscent();
     int leading = fm.getLeading();
-    int horizMargin = 
+    int horizMargin =
       (getSize().width - width)/2;
-    int verMargin = 
+    int verMargin =
       (getSize().height - height)/2;
     g.setColor(Color.red);
-    g.drawString(label, horizMargin, 
+    g.drawString(label, horizMargin,
       verMargin + ascent + leading);
   }
   class AL implements ActionListener {
@@ -2921,7 +2920,7 @@ class MyButton extends Button {
     }
   }
 }
-  
+
 public class GoodTechnique extends Frame {
   GoodTechnique() {
     setLayout(new GridLayout(2,2));
@@ -3031,19 +3030,19 @@ class EnabledPanel extends Panel {
   processComponentEvent(ComponentEvent e) {
     switch(e.getID()) {
       case ComponentEvent.COMPONENT_MOVED:
-        display.evnt[Display.COMPONENT] = 
+        display.evnt[Display.COMPONENT] =
           "Component moved";
         break;
       case ComponentEvent.COMPONENT_RESIZED:
-        display.evnt[Display.COMPONENT] = 
+        display.evnt[Display.COMPONENT] =
           "Component resized";
         break;
       case ComponentEvent.COMPONENT_HIDDEN:
-        display.evnt[Display.COMPONENT] = 
+        display.evnt[Display.COMPONENT] =
           "Component hidden";
         break;
       case ComponentEvent.COMPONENT_SHOWN:
-        display.evnt[Display.COMPONENT] = 
+        display.evnt[Display.COMPONENT] =
           "Component shown";
         break;
       default:
@@ -3056,11 +3055,11 @@ class EnabledPanel extends Panel {
   public void processFocusEvent(FocusEvent e) {
     switch(e.getID()) {
       case FocusEvent.FOCUS_GAINED:
-        display.evnt[Display.FOCUS] = 
+        display.evnt[Display.FOCUS] =
           "FOCUS gained";
         break;
       case FocusEvent.FOCUS_LOST:
-        display.evnt[Display.FOCUS] = 
+        display.evnt[Display.FOCUS] =
           "FOCUS lost";
         break;
       default:
@@ -3071,21 +3070,21 @@ class EnabledPanel extends Panel {
   public void processKeyEvent(KeyEvent e) {
     switch(e.getID()) {
       case KeyEvent.KEY_PRESSED:
-        display.evnt[Display.KEY] = 
-          "KEY pressed: "; 
+        display.evnt[Display.KEY] =
+          "KEY pressed: ";
         break;
       case KeyEvent.KEY_RELEASED:
-        display.evnt[Display.KEY] = 
-          "KEY released: "; 
+        display.evnt[Display.KEY] =
+          "KEY released: ";
         break;
       case KeyEvent.KEY_TYPED:
-        display.evnt[Display.KEY] = 
+        display.evnt[Display.KEY] =
           "KEY typed: ";
         break;
       default:
     }
     int code = e.getKeyCode();
-    display.evnt[Display.KEY] += 
+    display.evnt[Display.KEY] +=
       KeyEvent.getKeyText(code);
     repaint();
     super.processKeyEvent(e);
@@ -3094,29 +3093,29 @@ class EnabledPanel extends Panel {
     switch(e.getID()) {
       case MouseEvent.MOUSE_CLICKED:
         requestFocus(); // Get FOCUS on click
-        display.evnt[Display.MOUSE] = 
+        display.evnt[Display.MOUSE] =
           "MOUSE clicked";
         break;
       case MouseEvent.MOUSE_PRESSED:
-        display.evnt[Display.MOUSE] = 
+        display.evnt[Display.MOUSE] =
           "MOUSE pressed";
         break;
       case MouseEvent.MOUSE_RELEASED:
-        display.evnt[Display.MOUSE] = 
+        display.evnt[Display.MOUSE] =
           "MOUSE released";
         break;
-      case MouseEvent.MOUSE_ENTERED: 
-        display.evnt[Display.MOUSE] = 
+      case MouseEvent.MOUSE_ENTERED:
+        display.evnt[Display.MOUSE] =
           "MOUSE entered";
         break;
-      case MouseEvent.MOUSE_EXITED: 
-        display.evnt[Display.MOUSE] = 
+      case MouseEvent.MOUSE_EXITED:
+        display.evnt[Display.MOUSE] =
           "MOUSE exited";
         break;
       default:
     }
-    display.evnt[Display.MOUSE] += 
-      ", x = " + e.getX() + 
+    display.evnt[Display.MOUSE] +=
+      ", x = " + e.getX() +
       ", y = " + e.getY();
     repaint();
     super.processMouseEvent(e);
@@ -3125,17 +3124,17 @@ class EnabledPanel extends Panel {
   processMouseMotionEvent(MouseEvent e) {
     switch(e.getID()) {
       case MouseEvent.MOUSE_DRAGGED:
-        display.evnt[Display.MOUSE_MOVE] = 
+        display.evnt[Display.MOUSE_MOVE] =
           "MOUSE dragged";
         break;
       case MouseEvent.MOUSE_MOVED:
-        display.evnt[Display.MOUSE_MOVE] = 
+        display.evnt[Display.MOUSE_MOVE] =
           "MOUSE moved";
         break;
       default:
     }
-    display.evnt[Display.MOUSE_MOVE] += 
-      ", x = " + e.getX() + 
+    display.evnt[Display.MOUSE_MOVE] +=
+      ", x = " + e.getX() +
       ", y = " + e.getY();
     repaint();
     super.processMouseMotionEvent(e);
@@ -3162,12 +3161,12 @@ class MyButton extends Button {
     int height = fm.getHeight();
     int ascent = fm.getAscent();
     int leading = fm.getLeading();
-    int horizMargin = 
+    int horizMargin =
       (getSize().width - width)/2;
-    int verMargin = 
+    int verMargin =
       (getSize().height - height)/2;
     g.setColor(Color.red);
-    g.drawString(label, horizMargin, 
+    g.drawString(label, horizMargin,
                  verMargin + ascent + leading);
   }
   public void processActionEvent(ActionEvent e) {
@@ -3178,7 +3177,7 @@ class MyButton extends Button {
     super.processActionEvent(e);
   }
 }
-  
+
 public class BadTechnique extends Frame {
   BadTechnique() {
     setLayout(new GridLayout(2,2));
@@ -3221,7 +3220,7 @@ import java.awt.*;
 import java.awt.event.*;
 
 public class PrintDemo extends Frame {
-  Button 
+  Button
     printText = new Button("Print Text"),
     printGraphics = new Button("Print Graphics");
   TextField ringNum = new TextField(3);
@@ -3269,7 +3268,7 @@ public class PrintDemo extends Frame {
     ChangeFont(String face, int style,int point){
       if(g != null) {
         g.setFont(new Font(face, style, point));
-        stringHeight = 
+        stringHeight =
           g.getFontMetrics().getHeight();
       }
     }
@@ -3280,23 +3279,23 @@ public class PrintDemo extends Frame {
   }
   class TBL implements ActionListener {
     public void actionPerformed(ActionEvent e) {
-      PrintData pd = 
+      PrintData pd =
         new PrintData("Print Text Test");
       // Null means print job canceled:
       if(pd == null) return;
       String s = "PrintDemo";
       ChangeFont cf = new ChangeFont(
         faces.getSelectedItem(), Font.ITALIC,72);
-      g.drawString(s, 
+      g.drawString(s,
         (pd.pageWidth - cf.stringWidth(s)) / 2,
         (pd.pageHeight - cf.stringHeight()) / 3);
 
       s = "A smaller point size";
       cf = new ChangeFont(
         faces.getSelectedItem(), Font.BOLD, 48);
-      g.drawString(s, 
+      g.drawString(s,
         (pd.pageWidth - cf.stringWidth(s)) / 2,
-        (int)((pd.pageHeight - 
+        (int)((pd.pageHeight -
            cf.stringHeight())/1.5));
       g.dispose();
       pd.end();
@@ -3304,7 +3303,7 @@ public class PrintDemo extends Frame {
   }
   class GBL implements ActionListener {
     public void actionPerformed(ActionEvent e) {
-      PrintData pd = 
+      PrintData pd =
         new PrintData("Print Graphics Test");
       if(pd == null) return;
       plot.print(g);
@@ -3358,7 +3357,7 @@ class Plot1 extends Plot {
       }
     }
   }
-} 
+}
 
 class Plot2 extends Plot {
   // To fit the picture to the page, you must
@@ -3366,11 +3365,11 @@ class Plot2 extends Plot {
   public void paint(Graphics g) {
     int w, h;
     if(g instanceof PrintGraphics) {
-      PrintJob pj = 
+      PrintJob pj =
         ((PrintGraphics)g).getPrintJob();
       w = pj.getPageDimension().width;
       h = pj.getPageDimension().height;
-    } 
+    }
     else {
       w = getSize().width;
       h = getSize().height;
@@ -3386,14 +3385,14 @@ class Plot2 extends Plot {
       }
     }
   }
-} 
+}
 
 class Plot3 extends Plot {
-  // Somewhat better. Separate 
+  // Somewhat better. Separate
   // printing from painting:
   public void print(Graphics g) {
     // Assume it's a PrintGraphics object:
-    PrintJob pj = 
+    PrintJob pj =
       ((PrintGraphics)g).getPrintJob();
     int w = pj.getPageDimension().width;
     int h = pj.getPageDimension().height;
@@ -3479,7 +3478,7 @@ public class CutAndPaste extends Frame {
     copy = new MenuItem("Copy"),
     paste = new MenuItem("Paste");
   TextArea text = new TextArea(20,20);
-  Clipboard clipbd = 
+  Clipboard clipbd =
     getToolkit().getSystemClipboard();
   public CutAndPaste() {
     cut.addActionListener(new CutL());
@@ -3495,7 +3494,7 @@ public class CutAndPaste extends Frame {
   class CopyL implements ActionListener {
     public void actionPerformed(ActionEvent e) {
       String selection = text.getSelectedText();
-      StringSelection clipString = 
+      StringSelection clipString =
         new StringSelection(selection);
       clipbd.setContents(clipString, clipString);
     }
@@ -3503,11 +3502,11 @@ public class CutAndPaste extends Frame {
   class CutL implements ActionListener {
     public void actionPerformed(ActionEvent e) {
       String selection = text.getSelectedText();
-      StringSelection clipString = 
+      StringSelection clipString =
         new StringSelection(selection);
       clipbd.setContents(clipString, clipString);
-      text.replaceRange("", 
-        text.getSelectionStart(), 
+      text.replaceRange("",
+        text.getSelectionStart(),
         text.getSelectionEnd());
     }
   }
@@ -3516,12 +3515,12 @@ public class CutAndPaste extends Frame {
       Transferable clipData =
         clipbd.getContents(CutAndPaste.this);
       try {
-        String clipString = 
+        String clipString =
           (String)clipData.
             getTransferData(
               DataFlavor.stringFlavor);
-        text.replaceRange(clipString, 
-          text.getSelectionStart(), 
+        text.replaceRange(clipString,
+          text.getSelectionStart(),
           text.getSelectionEnd());
       } catch(Exception ex) {
         System.out.println("not String flavor");
@@ -3577,16 +3576,16 @@ public class Frog {
   private Spots spots;
   private boolean jmpr;
   public int getJumps() { return jumps; }
-  public void setJumps(int newJumps) { 
+  public void setJumps(int newJumps) {
     jumps = newJumps;
   }
   public Color getColor() { return color; }
-  public void setColor(Color newColor) { 
-    color = newColor; 
+  public void setColor(Color newColor) {
+    color = newColor;
   }
   public Spots getSpots() { return spots; }
   public void setSpots(Spots newSpots) {
-    spots = newSpots; 
+    spots = newSpots;
   }
   public boolean isJumper() { return jmpr; }
   public void setJumper(boolean j) { jmpr = j; }
@@ -3634,22 +3633,22 @@ public class BeanDumper {
         bean.getName());
       System.exit(1);
     }
-    PropertyDescriptor[] properties = 
+    PropertyDescriptor[] properties =
       bi.getPropertyDescriptors();
     for(int i = 0; i < properties.length; i++) {
       Class p = properties[i].getPropertyType();
       System.out.println(
         "Property type:\n  " + p.getName());
       System.out.println(
-        "Property name:\n  " + 
+        "Property name:\n  " +
         properties[i].getName());
-      Method readMethod = 
+      Method readMethod =
         properties[i].getReadMethod();
       if(readMethod != null)
         System.out.println(
-          "Read method:\n  " + 
+          "Read method:\n  " +
           readMethod.toString());
-      Method writeMethod = 
+      Method writeMethod =
         properties[i].getWriteMethod();
       if(writeMethod != null)
         System.out.println(
@@ -3665,24 +3664,24 @@ public class BeanDumper {
         methods[i].getMethod().toString());
     System.out.println("======================");
     System.out.println("Event support:");
-    EventSetDescriptor[] events = 
+    EventSetDescriptor[] events =
       bi.getEventSetDescriptors();
     for(int i = 0; i < events.length; i++) {
       System.out.println("Listener type:\n  " +
         events[i].getListenerType().getName());
-      Method[] lm = 
+      Method[] lm =
         events[i].getListenerMethods();
       for(int j = 0; j < lm.length; j++)
         System.out.println(
           "Listener method:\n  " +
           lm[j].getName());
-      MethodDescriptor[] lmd = 
+      MethodDescriptor[] lmd =
         events[i].getListenerMethodDescriptors();
       for(int j = 0; j < lmd.length; j++)
         System.out.println(
           "Method descriptor:\n  " +
           lmd[j].getMethod().toString());
-      Method addListener = 
+      Method addListener =
         events[i].getAddListenerMethod();
       System.out.println(
           "Add Listener Method:\n  " +
@@ -3848,13 +3847,13 @@ public class BangBean extends Canvas
   }
   public void paint(Graphics g) {
     g.setColor(Color.black);
-    g.drawOval(xm - cSize/2, ym - cSize/2, 
+    g.drawOval(xm - cSize/2, ym - cSize/2,
       cSize, cSize);
   }
   // This is a unicast listener, which is
   // the simplest form of listener management:
   public void addActionListener (
-      ActionListener l) 
+      ActionListener l)
         throws TooManyListenersException {
     if(actionListener != null)
       throw new TooManyListenersException();
@@ -3871,9 +3870,9 @@ public class BangBean extends Canvas
       g.setFont(
         new Font(
           "TimesRoman", Font.BOLD, fontSize));
-      int width = 
+      int width =
         g.getFontMetrics().stringWidth(text);
-      g.drawString(text, 
+      g.drawString(text,
         (getSize().width - width) /2,
         getSize().height/2);
       g.dispose();
@@ -3986,14 +3985,14 @@ import java.applet.*;
 import javax.swing.*;
 
 public class JButtonDemo extends Applet {
-  JButton 
+  JButton
     b1 = new JButton("JButton 1"),
     b2 = new JButton("JButton 2");
   JTextField t = new JTextField(20);
   public void init() {
     ActionListener al = new ActionListener() {
       public void actionPerformed(ActionEvent e){
-        String name = 
+        String name =
           ((JButton)e.getSource()).getText();
         t.setText(name + " Pressed");
       }
@@ -4036,7 +4035,7 @@ import java.awt.event.*;
 import javax.swing.*;
 
 public class Show {
-  public static void 
+  public static void
   inFrame(JPanel jp, int width, int height) {
     String title = jp.getClass().toString();
     // Remove the word "class":
@@ -4081,7 +4080,7 @@ public class Borders extends JPanel {
     jp.setLayout(new BorderLayout());
     String nm = b.getClass().toString();
     nm = nm.substring(nm.lastIndexOf('.') + 1);
-    jp.add(new JLabel(nm, JLabel.CENTER), 
+    jp.add(new JLabel(nm, JLabel.CENTER),
       BorderLayout.CENTER);
     jp.setBorder(b);
     return jp;
@@ -4165,11 +4164,11 @@ import javax.swing.border.*;
 import java.lang.reflect.*;
 
 public class ButtonGroups extends JPanel {
-  static String[] ids = { 
-    "June", "Ward", "Beaver", 
+  static String[] ids = {
+    "June", "Ward", "Beaver",
     "Wally", "Eddie", "Lumpy",
   };
-  static JPanel 
+  static JPanel
   makeBPanel(Class bClass, String[] ids) {
     ButtonGroup bg = new ButtonGroup();
     JPanel jp = new JPanel();
@@ -4188,7 +4187,7 @@ public class ButtonGroups extends JPanel {
         ab = (AbstractButton)ctor.newInstance(
           new Object[]{ids[i]});
       } catch(Exception ex) {
-        System.out.println("can't create " + 
+        System.out.println("can't create " +
           bClass);
       }
       bg.add(ab);
@@ -4228,7 +4227,7 @@ public class Faces extends JPanel {
     new ImageIcon("face3.gif"),
     new ImageIcon("face4.gif"),
   };
-  JButton 
+  JButton
     jb = new JButton("JButton", faces[3]),
     jb2 = new JButton("Disable");
   boolean mad = false;
@@ -4285,7 +4284,7 @@ import javax.swing.*;
 
 public class Menus extends JPanel {
   static final Boolean
-    bT = new Boolean(true), 
+    bT = new Boolean(true),
     bF = new Boolean(false);
   // Dummy class to create type identifiers:
   static class MType { MType(int i) {} };
@@ -4294,7 +4293,7 @@ public class Menus extends JPanel {
     cb = new MType(2), // Checkbox menu item
     rb = new MType(3); // Radio button menu item
   JTextField t = new JTextField(10);
-  JLabel l = new JLabel("Icon Selected", 
+  JLabel l = new JLabel("Icon Selected",
     Faces.faces[0], JLabel.CENTER);
   ActionListener a1 = new ActionListener() {
     public void actionPerformed(ActionEvent e) {
@@ -4351,19 +4350,19 @@ public class Menus extends JPanel {
     // Menu name:
     { "Faces", new Character('a') },
     // Optinal last element is icon
-    { "Face 0", rb, new Character('0'), a2, bT, 
+    { "Face 0", rb, new Character('0'), a2, bT,
       Faces.faces[0] },
-    { "Face 1", rb, new Character('1'), a2, bT, 
+    { "Face 1", rb, new Character('1'), a2, bT,
       Faces.faces[1] },
-    { "Face 2", rb, new Character('2'), a2, bT, 
+    { "Face 2", rb, new Character('2'), a2, bT,
       Faces.faces[2] },
-    { "Face 3", rb, new Character('3'), a2, bT, 
+    { "Face 3", rb, new Character('3'), a2, bT,
       Faces.faces[3] },
-    { "Face 4", rb, new Character('4'), a2, bT, 
+    { "Face 4", rb, new Character('4'), a2, bT,
       Faces.faces[4] },
   };
   public Object[] menuBar = {
-    fileMenu, editMenu, faceMenu, 
+    fileMenu, editMenu, faceMenu,
     optionMenu, helpMenu,
   };
   static public JMenuBar
@@ -4375,7 +4374,7 @@ public class Menus extends JPanel {
     return menuBar;
   }
   static ButtonGroup bgroup;
-  static public JMenu 
+  static public JMenu
   createMenu(Object[][] menuData) {
     JMenu menu = new JMenu();
     menu.setText((String)menuData[0][0]);
@@ -4392,7 +4391,7 @@ public class Menus extends JPanel {
     }
     return menu;
   }
-  static public JMenuItem 
+  static public JMenuItem
   createMenuItem(Object[] data) {
     JMenuItem m = null;
     MType type = (MType)data[1];
@@ -4417,7 +4416,7 @@ public class Menus extends JPanel {
   }
   Menus() {
     setLayout(new BorderLayout());
-    add(createMenuBar(menuBar), 
+    add(createMenuBar(menuBar),
       BorderLayout.NORTH);
     JPanel p = new JPanel();
     p.setLayout(new BorderLayout());
@@ -4533,7 +4532,7 @@ import javax.swing.border.*;
 
 public class Progress extends JPanel {
   JProgressBar pb = new JProgressBar();
-  JSlider sb = 
+  JSlider sb =
     new JSlider(JSlider.HORIZONTAL, 0, 100, 60);
   public Progress() {
     setLayout(new GridLayout(2,1));
@@ -4577,8 +4576,8 @@ class Branch {
     for(int i = 1; i < data.length; i++)
       r.add(new DefaultMutableTreeNode(data[i]));
   }
-  public DefaultMutableTreeNode node() { 
-    return r; 
+  public DefaultMutableTreeNode node() {
+    return r;
   }
 }  
 
@@ -4600,7 +4599,7 @@ public class Trees extends JPanel {
     root = new DefaultMutableTreeNode("root");
     tree = new JTree(root);
     // Add it and make it take care of scrolling:
-    add(new JScrollPane(tree), 
+    add(new JScrollPane(tree),
       BorderLayout.CENTER);
     // Capture the tree's model:
     model =(DefaultTreeModel)tree.getModel();
@@ -4613,11 +4612,11 @@ public class Trees extends JPanel {
           chosen = (DefaultMutableTreeNode)
             tree.getLastSelectedPathComponent();
           if(chosen == null) chosen = root;
-          // The model will create the 
+          // The model will create the
           // appropriate event. In response, the
           // tree will update itself:
           model.insertNodeInto(child, chosen, 0);
-          // This puts the new node on the 
+          // This puts the new node on the
           // currently chosen node.
         }
       }
@@ -4670,24 +4669,24 @@ class DataModel extends AbstractTableModel {
   DataModel() {
     addTableModelListener(new TML());
   }
-  public int getColumnCount() { 
-    return data[0].length; 
+  public int getColumnCount() {
+    return data[0].length;
   }
-  public int getRowCount() { 
+  public int getRowCount() {
     return data.length;
   }
-  public Object getValueAt(int row, int col) { 
-    return data[row][col]; 
+  public Object getValueAt(int row, int col) {
+    return data[row][col];
   }
-  public void 
+  public void
   setValueAt(Object val, int row, int col) {
     data[row][col] = val;
     // Indicate the change has happened:
     fireTableDataChanged();
   }
-  public boolean 
-  isCellEditable(int row, int col) { 
-    return true; 
+  public boolean
+  isCellEditable(int row, int col) {
+    return true;
   }
 };       
 
@@ -4695,7 +4694,7 @@ public class Table extends JPanel {
   public Table() {
     setLayout(new BorderLayout());
     JTable table = new JTable(new DataModel());
-    JScrollPane scrollpane = 
+    JScrollPane scrollpane =
       JTable.createScrollPaneForTable(table);
     add(scrollpane, BorderLayout.CENTER);
   }
@@ -4747,7 +4746,7 @@ public class Tabbed extends JPanel {
     setLayout(new BorderLayout());
     JTabbedPane tabbed = new JTabbedPane();
     for(int i = 0; i < q.length; i++)
-      tabbed.addTab((String)q[i][0], 
+      tabbed.addTab((String)q[i][0],
         makePanel((Class)q[i][1]));
     add(tabbed, BorderLayout.CENTER);
     tabbed.setSelectedIndex(q.length/2);
@@ -4795,4 +4794,4 @@ makePanel()方法获取我们想创建的类Class对象和用newInstance()去创
 (8)修改CardLayout1.java以便它使用Java 1.1的事件模型。
 (9)增加Frog.class到本章出现的清单文件中并运行jar以创建一个包括Frog和BangBean的JAR文件。现在从SUN公司处下载并安装BDK或者使用我们自己的可激活Bean的程序构建工具并增加JAR文件到我们的环境中，因此我们可以测试两个Bean。
 (10)创建我们自己的包括两个属性：一个布尔值为“on”，另一个为整型“level”，称为Valve的Java Bean。创建一个清单文件，利用jar打包我们的Bean，然后读入它到beanbox或到我们自己的激活程序构建工具里，因此我们可以测试它。
-(11)修改Menus.java，以便它处理多级菜单。这要假设读者已经熟悉了HTML的基础知识。但那些东西并不难理解，而且有一些书和资料可供参考。
+(11)修改Menus.java，以便它处理多级菜单。这要假设读者已经熟悉了HTML的基础知识。但那些东西并不难理解，而且有一些书和资料可供参考。
\ No newline at end of file

第14章 多线程.md

@@ -3,7 +3,7 @@
 
 利用对象，可将一个程序分割成相互独立的区域。我们通常也需要将一个程序转换成多个独立运行的子任务。
 
-象这样的每个子任务都叫作一个“线程”（Thread）。编写程序时，可将每个线程都想象成独立运行，而且都有自己的专用CPU。一些基础机制实际会为我们自动分割CPU的时间。我们通常不必关心这些细节问题，所以多线程的代码编写是相当简便的。
+象这样的每个子任务都叫作一个“线程”（`Thread`）。编写程序时，可将每个线程都想象成独立运行，而且都有自己的专用CPU。一些基础机制实际会为我们自动分割CPU的时间。我们通常不必关心这些细节问题，所以多线程的代码编写是相当简便的。
 
 这时理解一些定义对以后的学习狠有帮助。“进程”是指一种“自包容”的运行程序，有自己的地址空间。“多任务”操作系统能同时运行多个进程（程序）——但实际是由于CPU分时机制的作用，使每个进程都能循环获得自己的CPU时间片。但由于轮换速度非常快，使得所有程序好象是在“同时”运行一样。“线程”是进程内部单一的一个顺序控制流。因此，一个进程可能容纳了多个同时执行的线程。
 

第16章 设计范式.md

@@ -2,7 +2,7 @@
 
 本章要向大家介绍重要但却并不是那么传统的“模式”（Pattern）程序设计方法。
 
-在向面向对象程序设计的演化过程中，或许最重要的一步就是“设计模式”（Design Pattern）的问世。它在由Gamma，Helm和Johnson编著的《设计模式》一书中被定义成一个“里程碑”（该书由Addison-Wesley于1995年出版，注释①）。那本书列出了解决这个问题的23种不同的方法。在本章中，我们准备伴随几个例子揭示出设计模式的基本概念。这或许能激起您阅读《Design Pattern》一书的欲望。事实上，那本书现在已成为几乎所有OOP程序员都必备的参考书。
+在向面向对象程序设计的演化过程中，或许最重要的一步就是“设计模式”（Design Pattern）的问世。它在由Gamma，Helm和Johnson编著的《设计模式》一书中被定义成一个“里程碑”（该书由Addison-Wesley于1995年出版，注释①）。那本书列出了解决这个问题的23种不同的方法。在本章中，我们准备伴随几个例子揭示出设计模式的基本概念。这或许能激起您阅读《设计模式》一书的欲望。事实上，那本书现在已成为几乎所有OOP程序员都必备的参考书。
 
 ①：但警告大家：书中的例子是用C++写的。
 

第5章 隐藏实施过程.md

@@ -7,6 +7,6 @@
 
 为达到这个目的，需遵守一定的约定或规则。例如，库程序员在修改库内的一个类时，必须保证不删除已有的方法，因为那样做会造成客户程序员代码出现断点。然而，相反的情况却是令人痛苦的。对于一个数据成员，库的创建者怎样才能知道哪些数据成员已受到客户程序员的访问呢？若方法属于某个类唯一的一部分，而且并不一定由客户程序员直接使用，那么这种痛苦的情况同样是真实的。如果库的创建者想删除一种旧有的实现方案，并置入新代码，此时又该怎么办呢？对那些成员进行的任何改动都可能中断客户程序员的代码。所以库创建者处在一个尴尬的境地，似乎根本动弹不得。
 
-为解决这个问题，Java推出了“访问指示符”的概念，允许库创建者声明哪些东西是客户程序员可以使用的，哪些是不可使用的。这种访问控制的级别在“最大访问”和“最小访问”的范围之间，分别包括：public，“友好的”（无关键字），protected以及private。根据前一段的描述，大家或许已总结出作为一名库设计者，应将所有东西都尽可能保持为“private”（私有），并只展示出那些想让客户程序员使用的方法。这种思路是完全正确的，尽管它有点儿违背那些用其他语言（特别是C）编程的人的直觉，那些人习惯于在没有任何限制的情况下访问所有东西。到这一章结束时，大家应该可以深刻体会到Java访问控制的价值。
+为解决这个问题，Java推出了“访问指示符”的概念，允许库创建者声明哪些东西是客户程序员可以使用的，哪些是不可使用的。这种访问控制的级别在“最大访问”和“最小访问”的范围之间，分别包括：`public`，“友好的”（无关键字），`protected`以及`private`。根据前一段的描述，大家或许已总结出作为一名库设计者，应将所有东西都尽可能保持为`private`（私有），并只展示出那些想让客户程序员使用的方法。这种思路是完全正确的，尽管它有点儿违背那些用其他语言（特别是C）编程的人的直觉，那些人习惯于在没有任何限制的情况下访问所有东西。到这一章结束时，大家应该可以深刻体会到Java访问控制的价值。
 
-然而，组件库以及控制谁能访问那个库的组件的概念现在仍不是完整的。仍存在这样一个问题：如何将组件绑定到单独一个统一的库单元里。这是通过Java的package（打包）关键字来实现的，而且访问指示符要受到类在相同的包还是在不同的包里的影响。所以在本章的开头，大家首先要学习库组件如何置入包里。这样才能理解访问指示符的完整含义。
+然而，组件库以及控制谁能访问那个库的组件的概念现在仍不是完整的。仍存在这样一个问题：如何将组件绑定到单独一个统一的库单元里。这是通过Java的`package`（打包）关键字来实现的，而且访问指示符要受到类在相同的包还是在不同的包里的影响。所以在本章的开头，大家首先要学习库组件如何置入包里。这样才能理解访问指示符的完整含义。

第6章 类再生.md

@@ -10,4 +10,3 @@
 第二种方法则显得稍微有些技巧。它创建一个新类，将其作为现有类的一个“类型”。我们可以原样采取现有类的形式，并在其中加入新代码，同时不会对现有的类产生影响。这种魔术般的行为叫作“继承”（Inheritance），涉及的大多数工作都是由编译器完成的。对于面向对象的程序设计，“继承”是最重要的基础概念之一。它对我们下一章要讲述的内容会产生一些额外的影响。
 
 对于合成与继承这两种方法，大多数语法和行为都是类似的（因为它们都要根据现有的类型生成新类型）。在本章，我们将深入学习这些代码复用或者重复使用的机制。
-

第7章 多形性.md

@@ -5,6 +5,6 @@
 
 “多态性”（Polymorphism）从另一个角度将接口从具体的实现细节中分离出来，亦即实现了“是什么”与“怎样做”两个模块的分离。利用多态性的概念，代码的组织以及可读性均能获得改善。此外，还能创建“易于扩展”的程序。无论在项目的创建过程中，还是在需要加入新特性的时候，它们都可以方便地“成长”。
 
-通过合并各种特征与行为，封装技术可创建出新的数据类型。通过对具体实现细节的隐藏，可将接口与实现细节分离，使所有细节成为“private”（私有）。这种组织方式使那些有程序化编程背景人感觉颇为舒适。但多态性却涉及对“类型”的分解。通过上一章的学习，大家已知道通过继承可将一个对象当作它自己的类型或者它自己的基类型对待。这种能力是十分重要的，因为多个类型（从相同的基类型中派生出来）可被当作同一种类型对待。而且只需一段代码，即可对所有不同的类型进行同样的处理。利用具有多态性的方法调用，一种类型可将自己与另一种相似的类型区分开，只要它们都是从相同的基类型中派生出来的。这种区分是通过各种方法在行为上的差异实现的，可通过基类实现对那些方法的调用。
+通过合并各种特征与行为，封装技术可创建出新的数据类型。通过对具体实现细节的隐藏，可将接口与实现细节分离，使所有细节成为`private`（私有）。这种组织方式使那些有程序化编程背景人感觉颇为舒适。但多态性却涉及对“类型”的分解。通过上一章的学习，大家已知道通过继承可将一个对象当作它自己的类型或者它自己的基类型对待。这种能力是十分重要的，因为多个类型（从相同的基类型中派生出来）可被当作同一种类型对待。而且只需一段代码，即可对所有不同的类型进行同样的处理。利用具有多态性的方法调用，一种类型可将自己与另一种相似的类型区分开，只要它们都是从相同的基类型中派生出来的。这种区分是通过各种方法在行为上的差异实现的，可通过基类实现对那些方法的调用。
 
 在这一章中，大家要由浅入深地学习有关多态性的问题（也叫作动态绑定、推迟绑定或者运行期绑定）。同时举一些简单的例子，其中所有无关的部分都已剥除，只保留与多态性有关的代码。

第9章 违例差错控制.md

@@ -6,11 +6,11 @@ Java的基本原理就是“形式错误的代码不会运行”。
 
 在C++和其他早期语言中，可通过几种手续来达到这个目的。而且它们通常是作为一种规定建立起来的，而非作为程序设计语言的一部分。典型地，我们需要返回一个值或设置一个标志（位），接收者会检查这些值或标志，判断具体发生了什么事情。然而，随着时间的流逝，终于发现这种做法会助长那些使用一个库的程序员的麻痹情绪。他们往往会这样想：“是的，错误可能会在其他人的代码中出现，但不会在我的代码中”。这样的后果便是他们一般不检查是否出现了错误（有时出错条件确实显得太愚蠢，不值得检验；注释①）。另一方面，若每次调用一个方法时都进行全面、细致的错误检查，那么代码的可读性也可能大幅度降低。由于程序员可能仍然在用这些语言维护自己的系统，所以他们应该对此有着深刻的体会：若按这种方式控制错误，那么在创建大型、健壮、易于维护的程序时，肯定会遇到不小的阻挠。
 
-①：C程序员研究一下printf()的返回值便知端详。
+①：C程序员研究一下`printf()`的返回值便知端详。
 
-解决的方法是在错误控制中排除所有偶然性，强制格式的正确。这种方法实际已有很长的历史，因为早在60年代便在操作系统里采用了“异常控制”手段；甚至可以追溯到BASIC语言的on error goto语句。但C++的异常控制建立在Ada的基础上，而Java又主要建立在C++的基础上（尽管它看起来更象Object Pascal）。
+解决的方法是在错误控制中排除所有偶然性，强制格式的正确。这种方法实际已有很长的历史，因为早在60年代便在操作系统里采用了“异常控制”手段；甚至可以追溯到BASIC语言的on error `goto`语句。但C++的异常控制建立在Ada的基础上，而Java又主要建立在C++的基础上（尽管它看起来更象Object Pascal）。
 
-“异常”（Exception）这个词表达的是一种“例外”情况，亦即正常情况之外的一种“异常”。在问题发生的时候，我们可能不知具体该如何解决，但肯定知道已不能不顾一切地继续下去。此时，必须坚决地停下来，并由某人、某地指出发生了什么事情，以及该采取何种对策。但为了真正解决问题，当地可能并没有足够多的信息。因此，我们需要将其移交给更级的负责人，令其作出正确的决定（类似一个命令链）。
+“异常”（`Exception`）这个词表达的是一种“例外”情况，亦即正常情况之外的一种“异常”。在问题发生的时候，我们可能不知具体该如何解决，但肯定知道已不能不顾一切地继续下去。此时，必须坚决地停下来，并由某人、某地指出发生了什么事情，以及该采取何种对策。但为了真正解决问题，当地可能并没有足够多的信息。因此，我们需要将其移交给更级的负责人，令其作出正确的决定（类似一个命令链）。
 
 异常机制的另一项好处就是能够简化错误控制代码。我们再也不用检查一个特定的错误，然后在程序的多处地方对其进行控制。此外，也不需要在方法调用的时候检查错误（因为保证有人能捕获这里的错误）。我们只需要在一个地方处理问题：“异常控制模块”或者“异常控制器”。这样可有效减少代码量，并将那些用于描述具体操作的代码与专门纠正错误的代码分隔开。一般情况下，用于读取、写入以及调试的代码会变得更富有条理。