Java编程思想第四版完整中文高清版(免费)

Java编程思想第四版完整中文高清版(免费)
Table of Contents
《 THINKING IN JAVA 》中文版 .............................................................................................................................................1
写在前面的话 ..............................................................................................................................................................................6
引言 ................................................................................................................................................................................................8
1. 前提......................................................................................................................................................................................8
2. Java 的学习.........................................................................................................................................................................8
3. 目标......................................................................................................................................................................................8
4. 联机文档.............................................................................................................................................................................9
5. 章节......................................................................................................................................................................................9
6. 练习....................................................................................................................................................................................12
7. 多媒体CD-ROM .............................................................................................................................................................12
8. 源代码................................................................................................................................................................................12
9. 编码样式...........................................................................................................................................................................14
10. Java版本.........................................................................................................................................................................14
11. 课程和培训.....................................................................................................................................................................14
12. 错误..................................................................................................................................................................................14
13. 封面设计 .........................................................................................................................................................................15
14. 致谢..................................................................................................................................................................................15
第 1 章 对象入门 .......................................................................................................................................................................27
1.1 抽象的进步.....................................................................................................................................................................27
1.2 对象的接口.....................................................................................................................................................................28
1.3 实现方案的隐藏............................................................................................................................................................29
1.4 方案的重复使用............................................................................................................................................................30
1.5 继承：重新使用接口...................................................................................................................................................30
1.5.1 改善基础类..............................................................................................................................................................30
1.5.2 等价与类似关系.....................................................................................................................................................31
1.6 多形对象的互换使用...................................................................................................................................................31
1.6.1 动态绑定..................................................................................................................................................................32
1.6.2 抽象的基础类和接口............................................................................................................................................32
1.7 对象的创建和存在时间...............................................................................................................................................33
1.7.1 集合与继承器.........................................................................................................................................................33
1.7.2 单根结构..................................................................................................................................................................34
1.7.3 集合库与方便使用集合........................................................................................................................................ 35
1.7.4 清除时的困境：由谁负责清除？......................................................................................................................35
1.8 违例控制：解决错误...................................................................................................................................................36
1.9 多线程..............................................................................................................................................................................37
1.10 永久性 ...........................................................................................................................................................................37
1.11 Java和因特网..............................................................................................................................................................37
1.11.1 什么是 Web？......................................................................................................................................................37
1.11.2 客户端编程（注释⑧） .....................................................................................................................................38
1.11.3 服务器端编程.......................................................................................................................................................41
1.11.4 一个独立的领域：应用程序............................................................................................................................. 41
1.12 分析和设计...................................................................................................................................................................42
1.12.1 不要迷失................................................................................................................................................................42
1.12.2 阶段 0：拟出一个计划....................................................................................................................................... 42
1.12.3 阶段 1：要制作什么？....................................................................................................................................... 43
1.12.4 阶段 2：如何构建？...........................................................................................................................................43
1.12.5 阶段 3：开始创建 ...............................................................................................................................................44
1.12.6 阶段 4：校订........................................................................................................................................................44
1.12.7 计划的回报 ...........................................................................................................................................................45
1.13 Java还是C ？........................................................................................................................................................45
 18
第 2 章 一切都是对象 ..............................................................................................................................................................46
2.1 用句柄操纵对象............................................................................................................................................................46
2.2 所有对象都必须创建...................................................................................................................................................46
2.2.1 保存到什么地方.....................................................................................................................................................46
2.2.2 特殊情况：主要类型............................................................................................................................................47
2.2.3 Java的数组............................................................................................................................................................. 48
2.3 绝对不要清除对象 .......................................................................................................................................................48
2.3.1 作用域......................................................................................................................................................................48
2.3.2 对象的作用域.........................................................................................................................................................49
2.4 新建数据类型：类 .......................................................................................................................................................49
2.4.1 字段和方法..............................................................................................................................................................49
2.5 方法、自变量和返回值...............................................................................................................................................50
2.5.1 自变量列表..............................................................................................................................................................51
2.6 构建Java 程序...............................................................................................................................................................52
2.6.1 名字的可见性.........................................................................................................................................................52
2.6.2 使用其他组件.........................................................................................................................................................52
2.6.3 static 关键字............................................................................................................................................................ 52
2.7 我们的第一个 Java 程序.............................................................................................................................................53
2.8 注释和嵌入文档............................................................................................................................................................55
2.8.1 注释文档..................................................................................................................................................................56
2.8.2 具体语法..................................................................................................................................................................56
2.8.3 嵌入 HTML............................................................................................................................................................. 56
2.8.4 @see：引用其他类...............................................................................................................................................57
2.8.5 类文档标记..............................................................................................................................................................57
2.8.6 变量文档标记.........................................................................................................................................................57
2.8.7 方法文档标记.........................................................................................................................................................57
2.8.8 文档示例..................................................................................................................................................................58
2.9 编码样式 .........................................................................................................................................................................59
2.10 总结................................................................................................................................................................................59
2.11 练习................................................................................................................................................................................59
第 3 章 控制程序流程 ..............................................................................................................................................................60
3.1 使用Java 运算符 ..........................................................................................................................................................60
3.1.1 优先级......................................................................................................................................................................60
3.1.2 赋值...........................................................................................................................................................................60
3.1.3 算术运算符..............................................................................................................................................................62
3.1.4 自动递增和递减.....................................................................................................................................................64
3.1.5 关系运算符..............................................................................................................................................................65
3.1.6 逻辑运算符..............................................................................................................................................................66
3.1.7 按位运算符..............................................................................................................................................................68
3.1.8 移位运算符..............................................................................................................................................................68
3.1.9 三元 if-else 运算符................................................................................................................................................71
3.1.10 逗号运算符 ...........................................................................................................................................................72
3.1.11 字串运算符 .........................................................................................................................................................72
3.1.12 运算符常规操作规则..........................................................................................................................................72
3.1.13 造型运算符 ...........................................................................................................................................................73
3.1.14 Java 没有“sizeof” ............................................................................................................................................74
3.1.15 复习计算顺序.......................................................................................................................................................75
3.1.16 运算符总结 ...........................................................................................................................................................75
3.2 执行控制 .........................................................................................................................................................................84
3.2.1 真和假......................................................................................................................................................................84
3.2.2 if-else........................................................................................................................................................................ 84
3.2.3 反复...........................................................................................................................................................................85
 19
3.2.4 do-while....................................................................................................................................................................85
3.2.5 for..............................................................................................................................................................................86
3.2.6 中断和继续..............................................................................................................................................................87
3.2.7 开关...........................................................................................................................................................................91
3.3 总结..................................................................................................................................................................................94
3.4 练习..................................................................................................................................................................................94
第 4 章 初始化和清除 ..............................................................................................................................................................95
4.1 用构建器自动初始化...................................................................................................................................................95
4.2 方法过载 .........................................................................................................................................................................96
4.2.1 区分过载方法.........................................................................................................................................................97
4.2.2 主类型的过载.........................................................................................................................................................98
4.2.3 返回值过载............................................................................................................................................................ 101
4.2.4 默认构建器............................................................................................................................................................ 102
4.2.5 this 关键字.............................................................................................................................................................102
4.3 清除：收尾和垃圾收集............................................................................................................................................105
4.3.1 finalize()用途何在................................................................................................................................................105
4.3.2 必须执行清除.......................................................................................................................................................106
4.4 成员初始化..................................................................................................................................................................108
4.4.1 规定初始化............................................................................................................................................................ 109
4.4.2 构建器初始化.......................................................................................................................................................111
4.5 数组初始化..................................................................................................................................................................116
4.5.1 多维数组................................................................................................................................................................119
4.6 总结...............................................................................................................................................................................121
4.7 练习...............................................................................................................................................................................121
第 5 章 隐藏实施过程 ...........................................................................................................................................................123
5.1 包：库单元..................................................................................................................................................................123
5.1.1 创建独一无二的包名..........................................................................................................................................124
5.1.2 自定义工具库.......................................................................................................................................................126
5.1.3 利用导入改变行为 ..............................................................................................................................................128
5.1.4 包的停用................................................................................................................................................................130
5.2 Java访问指示符 ........................................................................................................................................................130
5.2.1 “友好的”............................................................................................................................................................ 130
5.2.2 public：接口访问 ................................................................................................................................................131
5.2.3 private：不能接触！...........................................................................................................................................132
5.2.4 protected：“友好的一种”..............................................................................................................................133
5.3 接口与实现..................................................................................................................................................................134
5.4 类访问...........................................................................................................................................................................135
5.5 总结...............................................................................................................................................................................136
5.6 练习...............................................................................................................................................................................137
第 6 章 类再生 ........................................................................................................................................................................139
6.1 合成的语法..................................................................................................................................................................139
6.2 继承的语法..................................................................................................................................................................141
6.2.1 初始化基础类.......................................................................................................................................................143
6.3 合成与继承的结合 ....................................................................................................................................................145
6.3.1 确保正确的清除...................................................................................................................................................146
6.3.2 名字的隐藏............................................................................................................................................................ 148
6.4 到底选择合成还是继承............................................................................................................................................149
6.5 protected.......................................................................................................................................................................150
6.6 累积开发 ......................................................................................................................................................................151
6.7 上溯造型 ......................................................................................................................................................................151
6.7.1 何谓“上溯造型”？..........................................................................................................................................152
6.8 final关键字..................................................................................................................................................................152
6.8.1 final 数据................................................................................................................................................................152
 20
6.8.2 final 方法................................................................................................................................................................155
6.8.3 final 类....................................................................................................................................................................156
6.8.4 final 的注意事项 ..................................................................................................................................................156
6.9 初始化和类装载.........................................................................................................................................................157
6.9.1 继承初始化............................................................................................................................................................ 157
6.10 总结.............................................................................................................................................................................158
6.11 练习.............................................................................................................................................................................159
第 7 章 多形性 ........................................................................................................................................................................160
7.1 上溯造型 ......................................................................................................................................................................160
7.1.1 为什么要上溯造型 ..............................................................................................................................................161
7.2 深入理解 ......................................................................................................................................................................162
7.2.1 方法调用的绑定...................................................................................................................................................163
7.2.2 产生正确的行为...................................................................................................................................................163
7.2.3 扩展性....................................................................................................................................................................165
7.3 覆盖与过载..................................................................................................................................................................168
7.4 抽象类和方法 .............................................................................................................................................................169
7.5 接口...............................................................................................................................................................................172
7.5.1 Java的“多重继承”..........................................................................................................................................174
7.5.2 通过继承扩展接口 ..............................................................................................................................................176
7.5.3 常数分组................................................................................................................................................................177
7.5.4 初始化接口中的字段..........................................................................................................................................178
7.6 内部类...........................................................................................................................................................................179
7.6.1 内部类和上溯造型 ..............................................................................................................................................180
7.6.2 方法和作用域中的内部类.................................................................................................................................181
7.6.3 链接到外部类.......................................................................................................................................................186
7.6.4 static 内部类..........................................................................................................................................................187
7.6.5 引用外部类对象...................................................................................................................................................189
7.6.6 从内部类继承.......................................................................................................................................................190
7.6.7 内部类可以覆盖吗？..........................................................................................................................................190
7.6.8 内部类标识符.......................................................................................................................................................192
7.6.9 为什么要用内部类：控制框架.........................................................................................................................192
7.7 构建器和多形性.........................................................................................................................................................198
7.7.1 构建器的调用顺序 ..............................................................................................................................................198
7.7.2 继承和finalize()...................................................................................................................................................199
7.7.3 构建器内部的多形性方法的行为....................................................................................................................202
7.8 通过继承进行设计 ....................................................................................................................................................204
7.8.1 纯继承与扩展.......................................................................................................................................................205
7.8.2 下溯造型与运行期类型标识.............................................................................................................................206
7.9 总结...............................................................................................................................................................................208
7.10 练习.............................................................................................................................................................................208
第 8 章 对象的容纳 ................................................................................................................................................................209
8.1 数组...............................................................................................................................................................................209
8.1.1 数组和第一类对象 ..............................................................................................................................................209
8.1.2 数组的返回............................................................................................................................................................ 212
8.2 集合...............................................................................................................................................................................213
8.2.1 缺点：类型未知...................................................................................................................................................213
8.3 枚举器（反复器） ....................................................................................................................................................217
8.4 集合的类型..................................................................................................................................................................220
8.4.1 Vector.....................................................................................................................................................................220
8.4.2 BitSet......................................................................................................................................................................221
8.4.3 Stack.......................................................................................................................................................................222
8.4.4 Hashtable................................................................................................................................................................223
8.4.5 再论枚举器............................................................................................................................................................ 228
 21
8.5 排序...............................................................................................................................................................................229
8.6 通用集合库..................................................................................................................................................................232
8.7 新集合...........................................................................................................................................................................233
8.7.1 使用 Collections...................................................................................................................................................235
8.7.2 使用 Lists...............................................................................................................................................................238
8.7.3 使用 Sets................................................................................................................................................................242
8.7.4 使用Maps..............................................................................................................................................................244
8.7.5 决定实施方案.......................................................................................................................................................247
8.7.6 未支持的操作.......................................................................................................................................................253
8.7.7 排序和搜索............................................................................................................................................................ 255
8.7.8 实用工具................................................................................................................................................................259
8.8 总结...............................................................................................................................................................................261
8.9 练习...............................................................................................................................................................................262
第 9 章 违例差错控制 ...........................................................................................................................................................263
9.1 基本违例 ......................................................................................................................................................................263
9.1.1 违例自变量............................................................................................................................................................ 264
9.2 违例的捕获..................................................................................................................................................................264
9.2.1 try 块.......................................................................................................................................................................264
9.2.2 违例控制器............................................................................................................................................................ 265
9.2.3 违例规范................................................................................................................................................................265
9.2.4 捕获所有违例.......................................................................................................................................................266
9.2.5 重新“掷”出违例 ..............................................................................................................................................267
9.3 标准Java 违例............................................................................................................................................................ 270
9.3.1 RuntimeException的特殊情况.........................................................................................................................270
9.4 创建自己的违例.........................................................................................................................................................271
9.5 违例的限制..................................................................................................................................................................274
9.6 用 finally 清除.............................................................................................................................................................276
9.6.1 用 finally 做什么..................................................................................................................................................277
9.6.2 缺点：丢失的违例 ..............................................................................................................................................279
9.7 构建器...........................................................................................................................................................................280
9.8 违例匹配 ......................................................................................................................................................................283
9.8.1 违例准则................................................................................................................................................................284
9.9 总结...............................................................................................................................................................................284
9.10 练习.............................................................................................................................................................................284
第 10 章 J AVA IO 系统 .........................................................................................................................................................285
10.1 输入和输出................................................................................................................................................................285
10.1.1 InputStream的类型...........................................................................................................................................285
10.1.2 OutputStream的类型 ........................................................................................................................................286
10.2 增添属性和有用的接口 .........................................................................................................................................286
10.2.1 通过 FilterInputStream从 InputStream里读入数据...................................................................................287
10.2.2 通过 FilterOutputStream向 OutputStream 里写入数据.............................................................................287
10.3 本身的缺陷：RandomAccessFile.........................................................................................................................288
10.4 File类.........................................................................................................................................................................288
10.4.1 目录列表器 .........................................................................................................................................................288
10.4.2 检查与创建目录.................................................................................................................................................292
10.5 IO 流的典型应用......................................................................................................................................................294
10.5.1 输入流..................................................................................................................................................................296
10.5.2 输出流..................................................................................................................................................................298
10.5.3 快捷文件处理.....................................................................................................................................................298
10.5.4 从标准输入中读取数据....................................................................................................................................300
10.5.5 管道数据流 .........................................................................................................................................................300
10.6 StreamTokenizer........................................................................................................................................................300
 22
10.6.1 StringTokenizer ..................................................................................................................................................303
10.7 Java 1.1 的IO 流......................................................................................................................................................305
10.7.1 数据的发起与接收 ............................................................................................................................................305
10.7.2 修改数据流的行为 ............................................................................................................................................306
10.7.3 未改变的类 .........................................................................................................................................................306
10.7.4 一个例子..............................................................................................................................................................307
10.7.5 重导向标准 IO....................................................................................................................................................310
10.8 压缩.............................................................................................................................................................................311
10.8.1 用 GZIP进行简单压缩.....................................................................................................................................311
10.8.2 用 Zip 进行多文件保存....................................................................................................................................312
10.8.3 Java 归档（jar）实用程序...............................................................................................................................314
10.9 对象序列化................................................................................................................................................................315
10.9.1 寻找类..................................................................................................................................................................318
10.9.2 序列化的控制.....................................................................................................................................................319
10.9.3 利用“持久性”.................................................................................................................................................326
10.10 总结...........................................................................................................................................................................332
10.11 练习...........................................................................................................................................................................332
第 11 章 运行期类型鉴定 .....................................................................................................................................................333
11.1 对 RTTI 的需要.........................................................................................................................................................333
11.1.1 Class对象............................................................................................................................................................ 334
11.1.2 造型前的检查.....................................................................................................................................................337
11.2 RTTI 语法...................................................................................................................................................................342
11.3 反射：运行期类信息..............................................................................................................................................343
11.3.1 一个类方法提取器 ............................................................................................................................................344
11.4 总结.............................................................................................................................................................................347
11.5 练习.............................................................................................................................................................................348
第 12 章 传递和返回对象 .....................................................................................................................................................349
12.1 传递句柄....................................................................................................................................................................349
12.1.1 别名问题..............................................................................................................................................................349
12.2 制作本地副本...........................................................................................................................................................351
12.2.1 按值传递..............................................................................................................................................................351
12.2.2 克隆对象..............................................................................................................................................................352
12.2.3 使类具有克隆能力 ............................................................................................................................................353
12.2.4 成功的克隆 .........................................................................................................................................................353
12.2.5 Object.clone()的效果 ........................................................................................................................................355
12.2.6 克隆合成对象.....................................................................................................................................................356
12.2.7 用 Vector进行深层复制...................................................................................................................................358
12.2.8 通过序列化进行深层复制...............................................................................................................................359
12.2.9 使克隆具有更大的深度....................................................................................................................................361
12.2.10 为什么有这个奇怪的设计.............................................................................................................................362
12.3 克隆的控制................................................................................................................................................................363
12.3.1 副本构建器 .........................................................................................................................................................366
12.4 只读类 ........................................................................................................................................................................369
12.4.1 创建只读类 .........................................................................................................................................................370
12.4.2 “一成不变”的弊端........................................................................................................................................371
12.4.3 不变字串..............................................................................................................................................................373
12.4.4 String和 StringBuffer 类..................................................................................................................................374
12.4.5 字串的特殊性.....................................................................................................................................................376
12.5 总结.............................................................................................................................................................................376
12.6 练习.............................................................................................................................................................................376
第十三章 创建窗口和程序片 ..............................................................................................................................................378
13.1 为何要用 AWT？......................................................................................................................................................378
 23
13.2 基本程序片................................................................................................................................................................379
13.2.1 程序片的测试.....................................................................................................................................................380
13.2.2 一个更图形化的例子........................................................................................................................................381
13.2.3 框架方法的演示.................................................................................................................................................381
13.3 制作按钮....................................................................................................................................................................382
13.4 捕获事件....................................................................................................................................................................382
13.5 文本字段....................................................................................................................................................................384
13.6 文本区域....................................................................................................................................................................385
13.7 标签.............................................................................................................................................................................386
13.8 复选框 ........................................................................................................................................................................387
13.9 单选钮 ........................................................................................................................................................................388
13.10 下拉列表..................................................................................................................................................................389
13.11 列表框......................................................................................................................................................................390
13.11.1 handleEvent()....................................................................................................................................................391
13.12 布局的控制 .............................................................................................................................................................393
13.12.1 FlowLayout.......................................................................................................................................................393
13.12.2 BorderLayout....................................................................................................................................................393
13.12.3 GridLayout........................................................................................................................................................394
13.12.4 CardLayout........................................................................................................................................................394
13.12.5 GridBagLayout.................................................................................................................................................396
13.13 action 的替代品......................................................................................................................................................396
13.14 程序片的局限.........................................................................................................................................................400
13.14.1 程序片的优点...................................................................................................................................................401
13.15 视窗化应用 .............................................................................................................................................................401
13.15.1 菜单....................................................................................................................................................................401
13.15.2 对话框................................................................................................................................................................404
13.16 新型AWT.................................................................................................................................................................408
13.16.1 新的事件模型...................................................................................................................................................409
13.16.2 事件和接收者类型 ..........................................................................................................................................410
13.16.3 用 Java 1.1 AWT制作窗口和程序片..........................................................................................................414
13.16.4 再研究一下以前的例子 .................................................................................................................................416
13.16.5 动态绑定事件...................................................................................................................................................431
13.16.6 将事务逻辑与 UI逻辑区分开 ......................................................................................................................433
13.16.7 推荐编码方法...................................................................................................................................................435
13.17 Java 1.1 用户接口 API..........................................................................................................................................448
13.17.1 桌面颜色...........................................................................................................................................................448
13.17.2 打印....................................................................................................................................................................448
13.17.3 剪贴板................................................................................................................................................................454
13.18 可视编程和 Beans.................................................................................................................................................456
13.18.1 什么是 Bean......................................................................................................................................................457
13.18.2 用 Introspector提取BeanInfo.......................................................................................................................458
13.18.3 一个更复杂的 Bean ........................................................................................................................................463
13.18.4 Bean的封装......................................................................................................................................................465
13.18.5 更复杂的 Bean 支持........................................................................................................................................466
13.18.6 Bean更多的知识.............................................................................................................................................466
13.19 Swing 入门（注释⑦）.........................................................................................................................................467
13.19.1 Swing有哪些优点...........................................................................................................................................467
13.19.2 方便的转换.......................................................................................................................................................467
13.19.3 显示框架...........................................................................................................................................................468
13.19.4 工具提示...........................................................................................................................................................469
13.19.5 边框....................................................................................................................................................................469
13.19.6 按钮....................................................................................................................................................................470
13.19.7 按钮组................................................................................................................................................................471
 24
13.19.8 图标....................................................................................................................................................................472
13.19.9 菜单....................................................................................................................................................................474
13.19.10 弹出式菜单.....................................................................................................................................................477
13.19.11 列表框和组合框............................................................................................................................................479
13.19.12 滑杆和进度指示条........................................................................................................................................479
13.19.13 树......................................................................................................................................................................480
13.19.14 表格..................................................................................................................................................................482
13.19.15 卡片式对话框................................................................................................................................................483
13.19.16 Swing消息框.................................................................................................................................................485
13.19.17 Swing更多的知识.........................................................................................................................................485
13.20 总结...........................................................................................................................................................................485
13.21 练习...........................................................................................................................................................................486
第 14 章 多线程 ......................................................................................................................................................................487
14.1 反应灵敏的用户界面..............................................................................................................................................487
14.1.1 从线程继承 .........................................................................................................................................................489
14.1.2 针对用户界面的多线程....................................................................................................................................490
14.1.3 用主类合并线程.................................................................................................................................................493
14.1.4 制作多个线程.....................................................................................................................................................495
14.1.5 Daemon线程......................................................................................................................................................498
14.2 共享有限的资源.......................................................................................................................................................499
14.2.1 资源访问的错误方法........................................................................................................................................499
14.2.2 Java 如何共享资源............................................................................................................................................503
14.2.3 回顾Java Beans .................................................................................................................................................506
14.3 堵塞.............................................................................................................................................................................510
14.3.1 为何会堵塞 .........................................................................................................................................................510
14.3.2 死锁......................................................................................................................................................................518
14.4 优先级 ........................................................................................................................................................................521
14.4.1 线程组..................................................................................................................................................................525
14.5 回顾runnable............................................................................................................................................................ 530
14.5.1 过多的线程 .........................................................................................................................................................532
14.6 总结.............................................................................................................................................................................535
14.7 练习.............................................................................................................................................................................535
第 15 章 网络编程 ..................................................................................................................................................................537
15.1 机器的标识................................................................................................................................................................537
15.1.1 服务器和客户机.................................................................................................................................................538
15.1.2 端口：机器内独一无二的场所......................................................................................................................539
15.2 套接字 ........................................................................................................................................................................539
15.2.1 一个简单的服务器和客户机程序..................................................................................................................539
15.3 服务多个客户...........................................................................................................................................................543
15.4 数据报 ........................................................................................................................................................................547
15.5 一个 Web应用..........................................................................................................................................................551
15.5.1 服务器应用 .........................................................................................................................................................552
15.5.2 NameSender程序片..........................................................................................................................................556
15.5.3 要注意的问题.....................................................................................................................................................560
15.6 Java与 CGI 的沟通.................................................................................................................................................560
15.6.1 CGI 数据的编码.................................................................................................................................................561
15.6.2 程序片..................................................................................................................................................................562
15.6.3 用 C 写的 CGI 程序.......................................................................................................................................566
15.6.4 POST的概念 ......................................................................................................................................................573
15.7 用 JDBC连接数据库 ..............................................................................................................................................576
15.7.1 让示例运行起来.................................................................................................................................................578
15.7.2 查找程序的 GUI 版本.......................................................................................................................................580
 25
15.7.3 JDBC API 为何如何复杂.................................................................................................................................582
15.8 远程方法....................................................................................................................................................................582
15.8.1 远程接口概念.....................................................................................................................................................582
15.8.2 远程接口的实施.................................................................................................................................................583
15.8.3 创建根与干 .........................................................................................................................................................585
15.8.4 使用远程对象.....................................................................................................................................................585
15.8.5 RMI 的替选方案................................................................................................................................................586
15.9 总结.............................................................................................................................................................................586
15.10 练习...........................................................................................................................................................................586
第 16 章 设计范式 ..................................................................................................................................................................588
16.1.1 单子......................................................................................................................................................................588
16.1.2 范式分类..............................................................................................................................................................589
16.2 观察器范式................................................................................................................................................................590
16.3 模拟垃圾回收站.......................................................................................................................................................592
16.4 改进设计....................................................................................................................................................................595
16.4.1 “制作更多的对象”........................................................................................................................................595
16.4.2 用于原型创建的一个范式...............................................................................................................................597
16.5 抽象的应用................................................................................................................................................................604
16.6 多重派遣....................................................................................................................................................................607
16.6.1 实现双重派遣.....................................................................................................................................................607
16.7 访问器范式................................................................................................................................................................612
16.8 RTTI 真的有害吗......................................................................................................................................................618
16.9 总结.............................................................................................................................................................................620
16.10 练习...........................................................................................................................................................................621
第 17 章 项目 ..........................................................................................................................................................................622
17.1 文字处理....................................................................................................................................................................622
17.1.1 提取代码列表.....................................................................................................................................................622
17.1.2 检查大小写样式.................................................................................................................................................633
17.2 方法查找工具...........................................................................................................................................................639
17.3 复杂性理论................................................................................................................................................................643
17.4 总结.............................................................................................................................................................................649
17.5 练习.............................................................................................................................................................................649
附录 A 使用非 JAVA 代码 .................................................................................................................................................650
A.1 Java固有接口 ............................................................................................................................................................ 650
A.1.1 调用固有方法......................................................................................................................................................650
A.1.2 访问 JNI函数：JNIEnv自变量.......................................................................................................................652
A.1.3 传递和使用Java 对象........................................................................................................................................653
A.1.4 JNI和Java 异常..................................................................................................................................................654
A.1.5 JNI和线程处理 ...................................................................................................................................................655
A.1.6 使用现成代码......................................................................................................................................................655
A.2 微软的解决方案........................................................................................................................................................655
A.3 J/Direct.........................................................................................................................................................................655
A.3.1 @dll.import 引导命令........................................................................................................................................656
A.3.2 com.ms.win32包.................................................................................................................................................657
A.3.3 汇集........................................................................................................................................................................658
A.3.4 编写回调函数......................................................................................................................................................659
A.3.5 其他 J/Direct特性...............................................................................................................................................659
A.4 本原接口（RNI）......................................................................................................................................................660
A.4.1 RNI 总结...............................................................................................................................................................661
A.5 Java/COM 集成..........................................................................................................................................................661
A.5.1 COM 基础.............................................................................................................................................................662
A.5.2 MS Java/COM 集成............................................................................................................................................663
 26
A.5.3 用 Java 设计COM 服务器................................................................................................................................663
A.5.4 用 Java 设计COM 客户.....................................................................................................................................665
A.5.5 ActiveX/Beans集成............................................................................................................................................666
A.5.6 固有方法与程序片的注意事项........................................................................................................................666
A.6 CORBA .........................................................................................................................................................................666
A.6.1 CORBA 基础.......................................................................................................................................................666
A.6.2 一个例子...............................................................................................................................................................667
A.6.3 Java 程序片和 CORBA......................................................................................................................................671
A.6.4 比较 CORBA 与 RMI........................................................................................................................................671
A.7 总结...............................................................................................................................................................................671
附录 B 对比 C 和 J AVA ....................................................................................................................................................672
附录 C J AVA 编程规则 .........................................................................................................................................................677
附录 D 性能 ............................................................................................................................................................................679
D.1 基本方法.....................................................................................................................................................................679
D.2 寻找瓶颈.....................................................................................................................................................................679
D.2.1 安插自己的测试代码.........................................................................................................................................679
D.2.2 JDK性能评测[2].................................................................................................................................................679
D.2.3 特殊工具...............................................................................................................................................................680
D.2.4 性能评测的技巧..................................................................................................................................................680
D.3 提速方法.....................................................................................................................................................................680
D.3.1 常规手段...............................................................................................................................................................680
D.3.2 依赖语言的方法..................................................................................................................................................680
D.3.3 特殊情况...............................................................................................................................................................681
D.4 参考资源.....................................................................................................................................................................682
D.4.1 性能工具...............................................................................................................................................................682
D.4.2 Web 站点..............................................................................................................................................................682
D.4.3 文章........................................................................................................................................................................682
D.4.4 Java 专业书籍......................................................................................................................................................683
D.4.5 一般书籍...............................................................................................................................................................683
附录 E 关于垃圾收集的一些话 ..........................................................................................................................................684
附录 F 推荐读物 ....................................................................................................................................................................686
 27
第 1 章 对象入门
“为什么面向对象的编程会在软件开发领域造成如此震憾的影响？”
面向对象编程（OOP）具有多方面的吸引力。对管理人员，它实现了更快和更廉价的开发与维护过程。对分析
与设计人员，建模处理变得更加简单，能生成清晰、易于维护的设计方案。对程序员，对象模型显得如此高
雅和浅显。此外，面向对象工具以及库的巨大威力使编程成为一项更使人愉悦的任务。每个人都可从中获
益，至少表面如此。
如果说它有缺点，那就是掌握它需付出的代价。思考对象的时候，需要采用形象思维，而不是程序化的思
维。与程序化设计相比，对象的设计过程更具挑战性——特别是在尝试创建可重复使用（可再生）的对象
时。过去，那些初涉面向对象编程领域的人都必须进行一项令人痛苦的选择：
(1) 选择一种诸如Smalltalk 的语言，“出师”前必须掌握一个巨型的库。
(2) 选择几乎根本没有库的 C （注释①），然后深入学习这种语言，直至能自行编写对象库。
①：幸运的是，这一情况已有明显改观。现在有第三方库以及标准的C 库供选用。
事实上，很难很好地设计出对象——从而很难设计好任何东西。因此，只有数量相当少的“专家”能设计出
最好的对象，然后让其他人享用。对于成功的 OOP语言，它们不仅集成了这种语言的语法以及一个编译程序
（编译器），而且还有一个成功的开发环境，其中包含设计优良、易于使用的库。所以，大多数程序员的首
要任务就是用现有的对象解决自己的应用问题。本章的目标就是向大家揭示出面向对象编程的概念，并证明
它有多么简单。
本章将向大家解释Java 的多项设计思想，并从概念上解释面向对象的程序设计。但要注意在阅读完本章后，
并不能立即编写出全功能的Java 程序。所有详细的说明和示例会在本书的其他章节慢慢道来。
1.1 抽象的进步
所有编程语言的最终目的都是提供一种“抽象”方法。一种较有争议的说法是：解决问题的复杂程度直接取
决于抽象的种类及质量。这儿的“种类”是指准备对什么进行“抽象”？汇编语言是对基础机器的少量抽
象。后来的许多“命令式”语言（如FORTRAN，BASIC 和 C）是对汇编语言的一种抽象。与汇编语言相比，这
些语言已有了长足的进步，但它们的抽象原理依然要求我们着重考虑计算机的结构，而非考虑问题本身的结
构。在机器模型（位于“方案空间”）与实际解决的问题模型（位于“问题空间”）之间，程序员必须建立
起一种联系。这个过程要求人们付出较大的精力，而且由于它脱离了编程语言本身的范围，造成程序代码很
难编写，而且要花较大的代价进行维护。由此造成的副作用便是一门完善的“编程方法”学科。
为机器建模的另一个方法是为要解决的问题制作模型。对一些早期语言来说，如 LISP 和 APL，它们的做法是
“从不同的角度观察世界”——“所有问题都归纳为列表”或“所有问题都归纳为算法”。PROLOG则将所有
问题都归纳为决策链。对于这些语言，我们认为它们一部分是面向基于“强制”的编程，另一部分则是专为
处理图形符号设计的。每种方法都有自己特殊的用途，适合解决某一类的问题。但只要超出了它们力所能及
的范围，就会显得非常笨拙。
面向对象的程序设计在此基础上则跨出了一大步，程序员可利用一些工具表达问题空间内的元素。由于这种
表达非常普遍，所以不必受限于特定类型的问题。我们将问题空间中的元素以及它们在方案空间的表示物称
作“对象”（Object）。当然，还有一些在问题空间没有对应体的其他对象。通过添加新的对象类型，程序
可进行灵活的调整，以便与特定的问题配合。所以在阅读方案的描述代码时，会读到对问题进行表达的话
语。与我们以前见过的相比，这无疑是一种更加灵活、更加强大的语言抽象方法。总之，OOP允许我们根据
问题来描述问题，而不是根据方案。然而，仍有一个联系途径回到计算机。每个对象都类似一台小计算机；
它们有自己的状态，而且可要求它们进行特定的操作。与现实世界的“对象”或者“物体”相比，编程“对
象”与它们也存在共通的地方：它们都有自己的特征和行为。
Alan Kay 总结了 Smalltalk 的五大基本特征。这是第一种成功的面向对象程序设计语言，也是Java 的基础
语言。通过这些特征，我们可理解“纯粹”的面向对象程序设计方法是什么样的：
(1) 所有东西都是对象。可将对象想象成一种新型变量；它保存着数据，但可要求它对自身进行操作。理论
上讲，可从要解决的问题身上提出所有概念性的组件，然后在程序中将其表达为一个对象。
(2) 程序是一大堆对象的组合；通过消息传递，各对象知道自己该做些什么。为了向对象发出请求，需向那
 28
个对象“发送一条消息”。更具体地讲，可将消息想象为一个调用请求，它调用的是从属于目标对象的一个
子例程或函数。
(3) 每个对象都有自己的存储空间，可容纳其他对象。或者说，通过封装现有对象，可制作出新型对象。所
以，尽管对象的概念非常简单，但在程序中却可达到任意高的复杂程度。
(4) 每个对象都有一种类型。根据语法，每个对象都是某个“类”的一个“实例”。其中，“类”（Class）
是“类型”（Type）的同义词。一个类最重要的特征就是“能将什么消息发给它？”。
(5) 同一类所有对象都能接收相同的消息。这实际是别有含义的一种说法，大家不久便能理解。由于类型为
“圆”（Circle）的一个对象也属于类型为“形状”（Shape）的一个对象，所以一个圆完全能接收形状消
息。这意味着可让程序代码统一指挥“形状”，令其自动控制所有符合“形状”描述的对象，其中自然包括
“圆”。这一特性称为对象的“可替换性”，是OOP最重要的概念之一。
一些语言设计者认为面向对象的程序设计本身并不足以方便解决所有形式的程序问题，提倡将不同的方法组
合成“多形程序设计语言”（注释②）。
②：参见Timothy Budd编著的《Multiparadigm Programming in Leda》，Addison-Wesley 1995 年出版。
1.2 对象的接口
亚里士多德或许是认真研究“类型”概念的第一人，他曾谈及“鱼类和鸟类”的问题。在世界首例面向对象
语言Simula-67 中，第一次用到了这样的一个概念：
所有对象——尽管各有特色——都属于某一系列对象的一部分，这些对象具有通用的特征和行为。在
Simula-67 中，首次用到了class 这个关键字，它为程序引入了一个全新的类型（clas 和 type 通常可互换使
用；注释③）。
③：有些人进行了进一步的区分，他们强调“类型”决定了接口，而“类”是那个接口的一种特殊实现方
式。
Simula是一个很好的例子。正如这个名字所暗示的，它的作用是“模拟”（Simulate）象“银行出纳员”这
样的经典问题。在这个例子里，我们有一系列出纳员、客户、帐号以及交易等。每类成员（元素）都具有一
些通用的特征：每个帐号都有一定的余额；每名出纳都能接收客户的存款；等等。与此同时，每个成员都有
自己的状态；每个帐号都有不同的余额；每名出纳都有一个名字。所以在计算机程序中，能用独一无二的实
体分别表示出纳员、客户、帐号以及交易。这个实体便是“对象”，而且每个对象都隶属一个特定的
“类”，那个类具有自己的通用特征与行为。
因此，在面向对象的程序设计中，尽管我们真正要做的是新建各种各样的数据“类型”（Type），但几乎所
有面向对象的程序设计语言都采用了“class”关键字。当您看到“type”这个字的时候，请同时想到
“class”；反之亦然。
建好一个类后，可根据情况生成许多对象。随后，可将那些对象作为要解决问题中存在的元素进行处理。事
实上，当我们进行面向对象的程序设计时，面临的最大一项挑战性就是：如何在“问题空间”（问题实际存
在的地方）的元素与“方案空间”（对实际问题进行建模的地方，如计算机）的元素之间建立理想的“一对
一”对应或映射关系。
如何利用对象完成真正有用的工作呢？必须有一种办法能向对象发出请求，令其做一些实际的事情，比如完
成一次交易、在屏幕上画一些东西或者打开一个开关等等。每个对象仅能接受特定的请求。我们向对象发出
的请求是通过它的“接口”（Interface）定义的，对象的“类型”或“类”则规定了它的接口形式。“类
型”与“接口”的等价或对应关系是面向对象程序设计的基础。
下面让我们以电灯泡为例：
 29
Light lt = new Light();
lt.on();
在这个例子中，类型／类的名称是 Light，可向 Light 对象发出的请求包括包括打开（on）、关