Java编程思想（第三版）

　　内容简介目录从本书获得的各项大奖以及来自世界各地的读者评论中，不难看出这是一本经典之作。本书作者有多年的教学经验，对C、C++、Java语言都有独到、深入的理解。因此他非常了解如何教授Java语言这门课程，也非常明白语言教学中的难点及人们的困惑。作者以通俗易懂及小而直接的示例解释了一个个晦涩抽象的概念，精心选取“对读者理解Java语言来说最为重要”的部分编写成书。同时又在随书光盘中提供了大量参考材料—这也是本书绝对物超所值的地方。随书光盘没有包含本书的源代码（可以从支持网站www.MindView.net免费下载），而是提供了大量作者讲授的讨论课内容及本书的前2版内容。本书内容丰富—从Java的基础语法到最高级特性，适合各层次的Java程序员阅读，同时也是高等院校讲授面向对象程序设计语言及Java语言的绝佳教材。第1章对象导论11.1抽象过程11.2每个对象都有一个接口21.3每个对象都提供服务41.4被隐藏的具体实现51.5复用具体实现51.6继承：复用接口61.7伴随多态的可互换对象91.8对象的创建、使用和生命期121.8.1集合与迭代器131.8.2单根继承结构141.8.3向下转型与模板/泛型151.8.4确保正确清理151.9异常处理：处理错误161.10并发性171.11持久性171.12Java与Internet181.12.1Web是什么181.12.2客户端编程191.12.3服务器端编程231.12.4应用231.13Java为什么成功241.13.1系统易于表达、易于理解241.13.2类库的巨大影响力241.13.3错误处理241.13.4大型程序设计241.14Java与C++251.15总结26第2章一切都是对象272.1用引用操纵对象272.2必须由你创建所有对象282.2.1存储到什么地方282.2.2特例：基本类型292.2.3Java中的数组302.3永远不需要销毁对象302.3.1作用域302.3.2对象的作用域312.4创建新的数据类型：类312.5方法、参数和返回值332.6构建一个Java程序352.6.1名字可见性352.6.2运用其他构件352.6.3static 关键字362.7你的第一个Java程序372.8注释和嵌入式文档392.8.1注释文档392.8.2语法392.8.3嵌入式HTML402.8.4一些标签示例412.8.5文档示例422.9编码风格432.10总结432.11练习43第3章控制程序流程453.1使用Java操作符453.1.1优先级453.1.2赋值453.1.3算术操作符483.1.4自动递增和递减503.1.5关系操作符523.1.6逻辑操作符533.1.7按位操作符553.1.8移位操作符563.1.9三元操作符 if-else593.1.10逗号操作符603.1.11字符串操作符 +603.1.12使用操作符时常犯的错误613.1.13类型转换操作符613.1.14Java没有“sizeof”633.1.15再论优先级633.1.16操作符小结643.2执行流程控制733.2.1true和false733.2.2if-else733.2.3return743.2.4迭代753.2.5do-while763.2.6for763.2.7break和 continue783.2.8switch833.3总结863.4练习86第4章初始化与清理894.1用构造器确保初始化894.2方法重载914.2.1区分重载方法934.2.2涉及基本类型的重载934.2.3以返回值区分重载方法984.2.4缺省构造器984.2.5this关键字994.3清理：终结处理和垃圾回收1024.3.1finalize（）的用途何在1034.3.2你必须实施清理1034.3.3终结条件1044.3.4垃圾回收器如何工作1054.4成员初始化1074.4.1指定初始化1084.4.2构造器初始化1094.5数组初始化1154.6总结1214.7练习122第5章隐藏具体实现1255.1包：程序库单元1255.1.1创建独一无二的包名1275.1.2定制工具库1295.1.3用 import改变行为1305.1.4对使用包的忠告1305.2Java访问权限修饰词1315.2.1包访问权限1315.2.2public：接口访问权限1315.2.3private： 你无法访问1335.2.4protected：继承访问权限1345.3接口和实现1355.4类的访问权限1365.5总结1385.6练习139第6章复用类1416.1组合语法1416.2继承语法1446.3结合使用组合和继承1486.3.1确保正确清理1496.3.2名称屏蔽1526.4在组合与继承之间选择1536.5protected关键字1556.6增量开发1566.7向上转型1566.8final关键字1586.8.1final 数据1586.8.2final 方法1616.8.3final 类1636.8.4有关final的忠告1636.9初始化及类的加载1646.10总结1666.11练习166第7章多态1697.1再论向上转型1697.2转机1727.2.1方法调用绑定1727.2.2产生正确的行为1737.2.3可扩展性1757.2.4缺陷：“覆盖”私有方法1787.3抽象类和抽象方法1797.4构造器和多态1827.4.1构造器的调用顺序1827.4.2继承与清理1847.4.3构造器内部的多态方法的行为1867.5用继承进行设计1887.5.1纯继承与扩展1897.5.2向下转型与运行时类型识别1917.6总结1927.7练习193第8章接口与内部类1958.1接口1958.1.1Java中的多重继承1988.1.2通过继承来扩展接口2008.1.3群组常量2028.1.4初始化接口中的字段2038.1.5嵌套接口2048.2内部类2078.2.1内部类与向上转型2088.2.2在方法和作用域内的内部类2108.2.3匿名内部类2118.2.4链接到外部类2158.2.5嵌套类2168.2.6引用外围类的对象2188.2.7从多层嵌套类中访问外部类的成员2198.2.8内部类的继承2208.2.9内部类可以被覆盖吗2208.2.10局部内部类2228.2.11内部类标识符2238.3为什么需要内部类2248.3.1闭包与回调2268.3.2内部类与控制框架2288.4总结2338.5练习233第9章通过异常处理错误2359.1基本异常2359.2捕获异常2379.2.1try块2379.2.2异常处理程序2379.3创建自定义异常2389.4异常说明2419.5捕获所有异常2429.5.1重新抛出异常2439.5.2异常链2469.6Java标准异常2499.7使用finally进行清理2519.7.1finally用来做什么2529.7.2缺憾：异常丢失2549.8异常的限制2559.9构造器2589.10异常匹配2609.11其他可选方式2619.11.1历史2629.11.2观点2639.11.3把异常传递给控制台2659.11.4把“被检查的异常”转换为“不检查的异常”2659.12异常使用指南2679.13总结2679.14练习267第10章类型检查26910.1为什么需要RTTI26910.1.1Class对象27110.1.2类型转换前先做检查27310.2RTTI语法28210.3反射：运行时的类信息28410.4总结28810.5练习288第11章对象的集合29111.1数组29111.1.1数组是第一级对象29211.1.2返回一个数组29411.1.3Arrays类29611.1.4填充数组30211.1.5复制数组30411.1.6数组的比较30511.1.7数组元素的比较30611.1.8数组排序30811.1.9在已排序的数组中查找31011.1.10对数组的小结31111.2容器简介31111.2.1容器的打印31211.2.2填充容器31311.3容器的缺点：未知类型31911.3.1有时候它也能工作32011.3.2制作一个类型明确的ArrayList32211.4迭代器32311.5容器的分类法32611.6Collection的功能方法32811.7List的功能方法33111.7.1使用LinkedList制作栈33411.7.2使用LinkedList制作队列33511.8Set的功能方法33611.9Map的功能方法33911.9.1SortedMap34311.9.2LinkedHashMap34411.9.3散列法与散列码34511.9.4覆盖hashCode（）35311.10持有引用35611.11再论迭代器36011.12选择接口的不同实现36111.12.1对List的选择36111.12.2对Set的选择36411.12.3对Map的选择36611.13List的排序和查询36811.14实用方法36911.14.1设定Collection或Map为不可修改37111.14.2Collection或Map的同步控制37211.15未获支持的操作37311.16Java 1.0/1.1 的容器37511.16.1Vector和Enumeration37511.16.2Hashtable37611.16.3Stack37611.16.4BitSet37711.17总结37811.18练习379第12章Java I/O系统38312.1File类38312.1.1目录列表器38312.1.2目录的检查及创建38612.2输入和输出38812.2.1InputStream类型38912.2.2OutputStream类型38912.3添加属性和有用的接口39012.3.1通过FilterInputStream从Input-Stream读取数据39112.3.2通过FilterOutPutStream向OutputStream写入39112.4Reader和Writer39212.4.1数据的来源和去处39312.4.2更改流的行为39312.4.3未发生变化的类39412.5自我独立的类：RandomAccessFile39412.6I/O流的典型使用方式39512.6.1输入流39712.6.2输出流39812.6.3管道流39912.7文件读写的实用工具40012.8标准I/O40112.8.1从标准输入读取40112.8.2将System.out转换成PrintWriter40212.8.3标准I/O重定向40212.9新I/O40312.9.1转换数据40612.9.2获取基本类型40912.9.3视图缓冲器41112.9.4用缓冲器操纵数据41512.9.5缓冲器的细节41512.9.6存储器映射文件41912.9.7文件加锁42212.10压缩42412.10.1用GZIP进行简单压缩42412.10.2用Zip进行多文件保存42512.10.3Java档案文件42812.11对象序列化42912.11.1寻找类43212.11.2序列化的控制43312.11.3使用“持久性”44012.12Preferences44512.13正则表达式44712.13.1创建正则表达式44712.13.2量词44812.13.3模式和匹配器44912.13.4split（）45512.13.5替换操作45612.13.6reset（）45812.13.7正则表达式和Java I/O45912.13.8需要StringTokenizer吗45912.14总结46012.15练习461第13章并发46313.1动机46313.2基本线程46413.2.1让步46613.2.2休眠46713.2.3优先权46913.2.4后台线程47113.2.5加入到某个线程47313.2.6编码的变体47513.2.7建立有响应的用户界面48013.3共享受限资源48113.3.1不正确地访问资源48113.3.2资源冲突48413.3.3解决共享资源竞争48613.3.4临界区49113.4线程状态49513.5线程之间的协作49613.5.1等待与通知49613.5.2线程间使用管道进行输入/输出49913.5.3更复杂的协作50113.6死锁50113.7正确的停止方法50413.8中断阻塞线程50513.9线程组50613.10总结50713.11练习508第14章创建窗口与applet程序51114.1applet基础51214.1.1applet的限制51214.1.2applet的优势51314.1.3应用框架51314.1.4在Web浏览器中运行applet51414.1.5使用Appletviewer工具51614.1.6测试applet51614.2从命令行运行applet51714.3创建按钮52014.4捕获事件52014.5文本区域52214.6控制布局52414.6.1BorderLayout52414.6.2FlowLayout52514.6.3GridLayout52514.6.4GridBagLayout52614.6.5绝对定位52614.6.6BoxLayout52614.6.7最好的方式是什么53014.7Swing事件模型53014.7.1事件与监听器的类型53014.7.2跟踪多个事件53514.8Swing组件一览53714.8.1按钮53814.8.2图标54014.8.3工具提示54214.8.4文本域54214.8.5边框54414.8.6滚动面板54514.8.7一个迷你编辑器54714.8.8复选框54814.8.9单选按钮54914.8.10组合框（下拉列表）55014.8.11列表框55114.8.12页签面板55314.8.13消息框55414.8.14菜单55514.8.15弹出式菜单56014.8.16绘图56214.8.17对话框56414.8.18文件对话框56714.8.19Swing组件上的HTML56914.8.20滑块与进度条57014.8.21树57114.8.22表格57314.8.23选择外观57414.8.24剪贴板57614.9把applet打包进JAR文件57814.10为applet签名57914.11JNLP与Java Web Start58314.12编程技术58714.12.1动态绑定事件58714.12.2将业务逻辑与用户界面逻辑相分离58914.12.3规范方式59114.13Swing与并发59114.13.1再论Runnable59114.13.2管理并发59314.14可视化编程与JavaBean59614.14.1JavaBean是什么59714.14.2使用Introspector抽取出BeanInfo59814.14.3一个更复杂的Bean60314.14.4JavaBean与同步60614.14.5把Bean打包60914.14.6对Bean更高级的支持61014.14.7有关Bean的其他读物61114.15总结61114.16练习611第15章发现问题61515.1单元测试61615.1.1一个简单的测试框架61715.1.2JUnit62615.2利用断言提高可靠性63015.2.1断言语法63015.2.2为“按契约设计”使用断言63315.2.3示例：按契约设计＋白盒单元测试63515.3用Ant构建63915.3.1使所有事物自动化63915.3.2使用make的问题64015.3.3Ant：事实上的标准64015.3.4用CVS进行版本控制64315.3.5每日构建64515.4日志64515.4.1日志级别64715.4.2LogRecord64915.4.3处理器65015.4.4过滤器65415.4.5格式器65515.4.6例子：发送email报告日志消息65615.4.7通过名字空间控制日志级别65815.4.8大型工程的日志实践66015.4.9小结66215.5调试66315.5.1使用JDB调试66315.5.2图形化调试器66715.6剖析和优化66715.6.1追踪内存消费66815.6.2追踪CPU的使用66815.6.3覆盖测试66815.6.4JVM剖析接口66815.6.5使用HPROF66915.6.6线程性能67015.6.7优化指南67115.7doclet67115.8总结67215.9练习673第16章分析与设计67516.1方法学67516.2阶段0：制定计划67616.3阶段1：做什么67716.4阶段2：如何构建67916.4.1对象设计的五个阶段68016.4.2对象开发指南68116.5阶段3：构建系统核心68116.6阶段4：迭代用例68116.7阶段5：演化68216.8成功的计划68316.9极限编程68316.9.1优先编写测试68316.9.2结对编程68416.10过渡策略68516.10.1指南68516.10.2管理上的障碍68616.11总结687附录A对象的传递与返回689附录BJava编程指南723附录C补充材料731附录D资源735索引739

　　作者：BruceEckelBruceEckel从1986年至今，已经发表了超过150篇计算机技术文章，出版了6本书（其中4本是关于C++的），并且在全世界做了数百次演讲。他是《ThinkinginJava》、《ThinkinginC++》、《C++Inside&Out》《UsingC++》和《ThinkinginPatterns》的作者，同时还是《BlackBeltC++》文集的编辑。他的《ThinkinginC++》一本书在1995年被评为“最佳软件开发图书”，《ThinkinginJava》被评为1999年JavaWorld“最爱读者欢迎图书”，并且赢得了编辑首选图书奖。C++编程思想第2卷：实用编程技术>>更多作品

第1章  对象导论        1
1.1  抽象过程        1
1.2  每个对象都有一个接口        2
1.3  每个对象都提供服务        4
1.4  被隐藏的具体实现        5
1.5  复用具体实现        5
1.6  继承：复用接口        6
1.7  伴随多态的可互换对象        9
1.8  对象的创建、使用和生命期        12
1.8.1  集合与迭代器        13
1.8.2  单根继承结构        14
1.8.3  向下转型与模板/泛型        15
1.8.4  确保正确清理        15
1.9  异常处理：处理错误        16
1.10  并发性        17
1.11  持久性        17
1.12  Java与Internet        18
1.12.1  Web是什么        18
1.12.2  客户端编程        19
1.12.3  服务器端编程        23
1.12.4  应用        23
1.13  Java为什么成功        24
1.13.1  系统易于表达、易于理解        24
1.13.2  类库的巨大影响力        24
1.13.3  错误处理        24
1.13.4  大型程序设计        24
1.14  Java与C++        25
1.15  总结        26
第2章  一切都是对象        27
2.1  用引用操纵对象        27
2.2  必须由你创建所有对象        28
2.2.1  存储到什么地方        28
2.2.2  特例：基本类型        29
2.2.3  Java中的数组        30
2.3  永远不需要销毁对象        30
2.3.1  作用域        30
2.3.2  对象的作用域        31
2.4  创建新的数据类型：类        31
2.5  方法、参数和返回值        33
2.6  构建一个Java程序        35
2.6.1  名字可见性        35
2.6.2  运用其他构件        35
2.6.3  static 关键字        36
2.7  你的第一个Java程序        37
2.8  注释和嵌入式文档        39
2.8.1  注释文档        39
2.8.2  语法        39
2.8.3  嵌入式HTML        40
2.8.4  一些标签示例        41
2.8.5  文档示例        42
2.9  编码风格        43
2.10  总结        43
2.11  练习        43
第3章  控制程序流程        45
3.1  使用Java操作符        45
3.1.1  优先级        45
3.1.2  赋值        45
3.1.3  算术操作符        48
3.1.4  自动递增和递减        50
3.1.5  关系操作符        52
3.1.6  逻辑操作符        53
3.1.7  按位操作符        55
3.1.8  移位操作符        56
3.1.9  三元操作符 if-else        59
3.1.10  逗号操作符        60
3.1.11  字符串操作符 +        60
3.1.12  使用操作符时常犯的错误        61
3.1.13  类型转换操作符        61
3.1.14  Java没有“sizeof”        63
3.1.15  再论优先级        63
3.1.16  操作符小结        64
3.2  执行流程控制        73
3.2.1  true和false        73
3.2.2  if-else        73
3.2.3  return        74
3.2.4  迭代        75
3.2.5  do-while        76
3.2.6  for        76
3.2.7  break和 continue        78
3.2.8  switch        83
3.3  总结        86
3.4  练习        86
第4章  初始化与清理        89
4.1  用构造器确保初始化        89
4.2  方法重载        91
4.2.1  区分重载方法        93
4.2.2  涉及基本类型的重载        93
4.2.3  以返回值区分重载方法        98
4.2.4  缺省构造器        98
4.2.5  this关键字        99
4.3  清理：终结处理和垃圾回收        102
4.3.1  finalize()的用途何在        103
4.3.2  你必须实施清理        103
4.3.3  终结条件        104
4.3.4  垃圾回收器如何工作        105
4.4  成员初始化        107
4.4.1  指定初始化        108
4.4.2  构造器初始化        109
4.5  数组初始化        115
4.6  总结        121
4.7  练习        122
第5章  隐藏具体实现        125
5.1  包：程序库单元        125
5.1.1  创建独一无二的包名        127
5.1.2  定制工具库        129
5.1.3  用 import改变行为        130
5.1.4  对使用包的忠告        130
5.2  Java访问权限修饰词        131
5.2.1  包访问权限        131
5.2.2  public:接口访问权限        131
5.2.3  private: 你无法访问        133
5.2.4  protected：继承访问权限        134
5.3  接口和实现        135
5.4  类的访问权限        136
5.5  总结        138
5.6  练习        139
第6章  复用类        141
6.1  组合语法        141
6.2  继承语法        144
6.3  结合使用组合和继承        148
6.3.1  确保正确清理        149
6.3.2  名称屏蔽        152
6.4  在组合与继承之间选择        153
6.5  protected关键字        155
6.6  增量开发        156
6.7  向上转型        156
6.8  final关键字        158
6.8.1  final 数据        158
6.8.2  final 方法        161
6.8.3  final 类        163
6.8.4  有关final的忠告        163
6.9  初始化及类的加载        164
6.10  总结        166
6.11  练习        166
第7章  多态        169
7.1  再论向上转型        169
7.2  转机        172
7.2.1  方法调用绑定        172
7.2.2  产生正确的行为        173
7.2.3  可扩展性        175
7.2.4  缺陷：“覆盖”私有方法        178
7.3  抽象类和抽象方法        179
7.4  构造器和多态        182
7.4.1  构造器的调用顺序        182
7.4.2  继承与清理        184
7.4.3  构造器内部的多态方法的行为        186
7.5  用继承进行设计        188
7.5.1  纯继承与扩展        189
7.5.2  向下转型与运行时类型识别        191
7.6  总结        192
7.7  练习        193
第8章  接口与内部类        195
8.1  接口        195
8.1.1  Java中的多重继承        198
8.1.2  通过继承来扩展接口        200
8.1.3  群组常量        202
8.1.4  初始化接口中的字段        203
8.1.5  嵌套接口        204
8.2  内部类        207
8.2.1  内部类与向上转型        208
8.2.2  在方法和作用域内的内部类        210
8.2.3  匿名内部类        211
8.2.4  链接到外部类        215
8.2.5  嵌套类        216
8.2.6  引用外围类的对象        218
8.2.7  从多层嵌套类中访问外部类的成员        219
8.2.8  内部类的继承        220
8.2.9  内部类可以被覆盖吗        220
8.2.10  局部内部类        222
8.2.11  内部类标识符        223
8.3  为什么需要内部类        224
8.3.1  闭包与回调        226
8.3.2  内部类与控制框架        228
8.4  总结        233
8.5  练习        233
第9章  通过异常处理错误        235
9.1  基本异常        235
9.2  捕获异常        237
9.2.1  try块        237
9.2.2  异常处理程序        237
9.3  创建自定义异常        238
9.4  异常说明        241
9.5  捕获所有异常        242
9.5.1  重新抛出异常        243
9.5.2  异常链        246
9.6  Java标准异常        249
9.7  使用finally进行清理        251
9.7.1  finally用来做什么        252
9.7.2  缺憾：异常丢失        254
9.8  异常的限制        255
9.9  构造器        258
9.10  异常匹配        260
9.11  其他可选方式        261
9.11.1  历史        262
9.11.2  观点        263
9.11.3  把异常传递给控制台        265
9.11.4  把“被检查的异常”转换为“不检查的异常”        265
9.12  异常使用指南        267
9.13  总结        267
9.14  练习        267
第10章  类型检查        269
10.1  为什么需要RTTI        269
10.1.1  Class对象        271
10.1.2  类型转换前先做检查        273
10.2  RTTI语法        282
10.3  反射：运行时的类信息        284
10.4  总结        288
10.5  练习        288
第11章  对象的集合        291
11.1  数组        291
11.1.1  数组是第一级对象        292
11.1.2  返回一个数组        294
11.1.3  Arrays类        296
11.1.4  填充数组        302
11.1.5  复制数组        304
11.1.6  数组的比较        305
11.1.7  数组元素的比较        306
11.1.8  数组排序        308
11.1.9  在已排序的数组中查找        310
11.1.10  对数组的小结        311
11.2  容器简介        311
11.2.1  容器的打印        312
11.2.2  填充容器        313
11.3  容器的缺点：未知类型        319
11.3.1  有时候它也能工作        320
11.3.2  制作一个类型明确的ArrayList        322
11.4  迭代器        323
11.5  容器的分类法        326
11.6  Collection的功能方法        328
11.7  List的功能方法        331
11.7.1  使用LinkedList制作栈        334
11.7.2  使用LinkedList制作队列        335
11.8  Set的功能方法        336
11.9  Map的功能方法        339
11.9.1  SortedMap        343
11.9.2  LinkedHashMap        344
11.9.3  散列法与散列码        345
11.9.4  覆盖hashCode()        353
11.10  持有引用        356
11.11  再论迭代器        360
11.12  选择接口的不同实现        361
11.12.1  对List的选择        361
11.12.2  对Set的选择        364
11.12.3  对Map的选择        366
11.13  List的排序和查询        368
11.14  实用方法        369
11.14.1  设定Collection或Map为不可修改        371
11.14.2  Collection或Map的同步控制        372
11.15  未获支持的操作        373
11.16  Java 1.0/1.1 的容器        375
11.16.1  Vector和Enumeration        375
11.16.2  Hashtable        376
11.16.3  Stack        376
11.16.4  BitSet        377
11.17  总结        378
11.18  练习        379
第12章  Java I/O系统        383
12.1  File类        383
12.1.1  目录列表器        383
12.1.2  目录的检查及创建        386
12.2  输入和输出        388
12.2.1  InputStream类型        389
12.2.2  OutputStream类型        389
12.3  添加属性和有用的接口        390
12.3.1  通过FilterInputStream从Input-Stream读取数据        391
12.3.2  通过FilterOutPutStream向OutputStream写入        391
12.4  Reader和Writer        392
12.4.1  数据的来源和去处        393
12.4.2  更改流的行为        393
12.4.3  未发生变化的类        394
12.5  自我独立的类：RandomAccessFile        394
12.6  I/O流的典型使用方式        395
12.6.1  输入流        397
12.6.2  输出流        398
12.6.3  管道流        399
12.7  文件读写的实用工具        400
12.8  标准I/O        401
12.8.1  从标准输入读取        401
12.8.2  将System.out转换成PrintWriter        402
12.8.3  标准I/O重定向        402
12.9  新I/O        403
12.9.1  转换数据        406
12.9.2  获取基本类型        409
12.9.3  视图缓冲器        411
12.9.4  用缓冲器操纵数据        415
12.9.5  缓冲器的细节        415
12.9.6  存储器映射文件        419
12.9.7  文件加锁        422
12.10  压缩        424
12.10.1  用GZIP进行简单压缩        424
12.10.2  用Zip进行多文件保存        425
12.10.3  Java档案文件        428
12.11  对象序列化        429
12.11.1  寻找类        432
12.11.2  序列化的控制        433
12.11.3  使用“持久性”        440
12.12  Preferences        445
12.13  正则表达式        447
12.13.1  创建正则表达式        447
12.13.2  量词        448
12.13.3  模式和匹配器        449
12.13.4  split()        455
12.13.5  替换操作        456
12.13.6  reset()        458
12.13.7  正则表达式和Java I/O        459
12.13.8  需要StringTokenizer吗        459
12.14  总结        460
12.15  练习        461
第13章  并发        463
13.1  动机        463
13.2  基本线程        464
13.2.1  让步        466
13.2.2  休眠        467
13.2.3  优先权        469
13.2.4  后台线程        471
13.2.5  加入到某个线程        473
13.2.6  编码的变体        475
13.2.7  建立有响应的用户界面        480
13.3  共享受限资源        481
13.3.1  不正确地访问资源        481
13.3.2  资源冲突        484
13.3.3  解决共享资源竞争        486
13.3.4  临界区        491
13.4  线程状态        495
13.5  线程之间的协作        496
13.5.1  等待与通知        496
13.5.2  线程间使用管道进行输入/输出        499
13.5.3  更复杂的协作        501
13.6  死锁        501
13.7  正确的停止方法        504
13.8  中断阻塞线程        505
13.9  线程组        506
13.10  总结        507
13.11  练习        508
第14章  创建窗口与applet程序        511
14.1  applet基础        512
14.1.1  applet的限制        512
14.1.2  applet的优势        513
14.1.3  应用框架        513
14.1.4  在Web浏览器中运行applet        514
14.1.5  使用Appletviewer工具        516
14.1.6  测试applet        516
14.2  从命令行运行applet        517
14.3  创建按钮        520
14.4  捕获事件        520
14.5  文本区域        522
14.6  控制布局        524
14.6.1  BorderLayout        524
14.6.2  FlowLayout        525
14.6.3  GridLayout        525
14.6.4  GridBagLayout        526
14.6.5  绝对定位        526
14.6.6  BoxLayout        526
14.6.7  最好的方式是什么        530
14.7  Swing事件模型        530
14.7.1  事件与监听器的类型        530
14.7.2  跟踪多个事件        535
14.8  Swing组件一览        537
14.8.1  按钮        538
14.8.2  图标        540
14.8.3  工具提示        542
14.8.4  文本域        542
14.8.5  边框        544
14.8.6  滚动面板        545
14.8.7  一个迷你编辑器        547
14.8.8  复选框        548
14.8.9  单选按钮        549
14.8.10  组合框（下拉列表）        550
14.8.11  列表框        551
14.8.12  页签面板        553
14.8.13  消息框        554
14.8.14  菜单        555
14.8.15  弹出式菜单        560
14.8.16  绘图        562
14.8.17  对话框        564
14.8.18  文件对话框        567
14.8.19  Swing组件上的HTML        569
14.8.20  滑块与进度条        570
14.8.21  树        571
14.8.22  表格        573
14.8.23  选择外观        574
14.8.24  剪贴板        576
14.9  把applet打包进JAR文件        578
14.10  为applet签名        579
14.11  JNLP与Java Web Start        583
14.12  编程技术        587
14.12.1  动态绑定事件        587
14.12.2  将业务逻辑与用户界面逻辑相分离        589
14.12.3  规范方式        591
14.13  Swing与并发        591
14.13.1  再论Runnable        591
14.13.2  管理并发        593
14.14  可视化编程与JavaBean        596
14.14.1  JavaBean是什么        597
14.14.2  使用Introspector抽取出BeanInfo        598
14.14.3  一个更复杂的Bean        603
14.14.4  JavaBean与同步        606
14.14.5  把Bean打包        609
14.14.6  对Bean更高级的支持        610
14.14.7  有关Bean的其他读物        611
14.15  总结        611
14.16  练习        611
第15章  发现问题        615
15.1  单元测试        616
15.1.1  一个简单的测试框架        617
15.1.2  JUnit        626
15.2  利用断言提高可靠性        630
15.2.1  断言语法        630
15.2.2  为“按契约设计”使用断言        633
15.2.3  示例：按契约设计＋白盒单元测试        635
15.3  用Ant构建        639
15.3.1  使所有事物自动化        639
15.3.2  使用make的问题        640
15.3.3  Ant：事实上的标准        640
15.3.4  用CVS进行版本控制        643
15.3.5  每日构建        645
15.4  日志        645
15.4.1  日志级别        647
15.4.2  LogRecord        649
15.4.3  处理器        650
15.4.4  过滤器        654
15.4.5  格式器        655
15.4.6  例子：发送email报告日志消息        656
15.4.7  通过名字空间控制日志级别        658
15.4.8  大型工程的日志实践        660
15.4.9  小结        662
15.5  调试        663
15.5.1  使用JDB调试        663
15.5.2  图形化调试器        667
15.6  剖析和优化        667
15.6.1  追踪内存消费        668
15.6.2  追踪CPU的使用        668
15.6.3  覆盖测试        668
15.6.4  JVM剖析接口        668
15.6.5  使用HPROF        669
15.6.6  线程性能        670
15.6.7  优化指南        671
15.7  doclet        671
15.8  总结        672
15.9  练习        673
第16章  分析与设计        675
16.1  方法学        675
16.2  阶段0：制定计划        676
16.3  阶段1：做什么        677
16.4  阶段2：如何构建        679
16.4.1  对象设计的五个阶段        680
16.4.2  对象开发指南        681
16.5  阶段3：构建系统核心        681
16.6  阶段4：迭代用例        681
16.7  阶段5：演化        682
16.8  成功的计划        683
16.9  极限编程        683
16.9.1  优先编写测试        683
16.9.2  结对编程        684
16.10  过渡策略        685
16.10.1  指南        685
16.10.2  管理上的障碍        686
16.11  总结        687
附录A  对象的传递与返回        689
附录B  Java编程指南        723
附录C  补充材料        731
附录D  资源        735
索引        739