Java编程思想（第三版）

第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