第1章 设计模式基础 1
1.1 设计模式是什么 2
1.1.1 什么是模式 2
1.1.2 设计模式的概念 2
1.1.3 设计模式的理解 3
1.1.4 设计模式的历史 4
1.2 设计模式有什么 4
1.2.1 设计模式的组成 4
1.2.2 设计模式的分类 4
1.3 设计模式的学习 5
1.3.1 为什么要学习设计模式 5
1.3.2 学习设计模式的层次 5
1.3.3 如何学习设计模式 6
1.4 本书的组织方式 7
1.4.1 本书所讲述的设计模式的提纲 7
1.4.2 每个模式的讲述结构 9
第2章 简单工厂 11
2.1 场景问题 12
2.1.1 接口回顾 12
2.1.2 面向接口编程 12
2.1.3 不用模式的解决方案 14
2.1.4 有何问题 15
2.2 解决方案 16
2.2.1 使用简单工厂来解决问题 16
2.2.2 简单工厂的结构和说明 16
2.2.3 简单工厂示例代码 17
2.2.4 使用简单工厂重写示例 19
2.3 模式讲解 20
2.3.1 典型疑问 20
2.3.2 认识简单工厂 21
2.3.3 简单工厂中方法的写法 22
2.3.4 可配置的简单工厂 24
2.3.5 简单工厂的优缺点 26
2.3.6 思考简单工厂 27
2.3.7 相关模式 27
第3章 外观模式 29
3.1 场景问题 30
3.1.1 生活中的示例 30
3.1.2 代码生成的应用 31
3.1.3 不用模式的解决方案 31
3.1.4 有何问题 35
3.2 解决方案 35
3.2.1 使用外观模式来解决问题 35
3.2.2 外观模式的结构和说明 36
3.2.3 外观模式示例代码 36
3.2.4 使用外观模式重写示例 39
3.3 模式讲解 40
3.3.1 认识外观模式 40
3.3.2 外观模式的实现 41
3.3.3 外观模式的优缺点 44
3.3.4 思考外观模式 44
3.3.5 相关模式 45
第4章 适配器模式（Adapter） 47
4.1 场景问题 48
4.1.1 装配电脑的例子 48
4.1.2 同时支持数据库和文件的日志管理 49
4.1.3 有何问题 54
4.2 解决方案 55
4.2.1 使适配器模式来解决问题 55
4.2.2 适配器模式的结构和说明 55
4.2.3 适配器模式示例代码 56
4.2.4 使用适配器模式来实现示例 58
4.3 模式讲解 61
4.3.1 认识适配器模式 61
4.3.2 适配器模式的实现 62
4.3.3 双向适配器 62
4.3.4 对象适配器和类适配器 66
4.3.5 适配器模式的优缺点 69
4.3.6 思考适配器模式 70
4.3.7 相关模式 70
第5章 单例模式（Singleton） 73
5.1 场景问题 74
5.1.1 读取配置文件的内容 74
5.1.2 不用模式的解决方案 74
5.1.3 有何问题 76
5.2 解决方案 76
5.2.1 使用单例模式来解决问题 76
5.2.2 单例模式的结构和说明 77
5.2.3 单例模式示例代码 77
5.2.4 使用单例模式重写示例 80
5.3 模式讲解 82
5.3.1 认识单例模式 82
5.3.2 懒汉式和饿汉式实现 83
5.3.3 延迟加载的思想 86
5.3.4 缓存的思想 87
5.3.5 Java中缓存的基本实现 88
5.3.6 利用缓存来实现单例模式 89
5.3.7 单例模式的优缺点 90
5.3.8 在Java中一种更好的单例实现方式 93
5.3.9 单例和枚举 94
5.3.10 思考单例模式 95
5.3.11 相关模式 97
第6章 工厂方法模式（Factory Method） 99
6.1 场景问题 100
6.1.1 导出数据的应用框架 100
6.1.2 框架的基础知识 100
6.1.3 有何问题 102
6.2 解决方案 103
6.2.1 使用工厂方法模式来解决问题 103
6.2.2 工厂方法模式的结构和说明 104
6.2.3 工厂方法模式示例代码 104
6.2.4 使用工厂方法模式来实现示例 105
6.3 模式讲解 108
6.3.1 认识工厂方法模式 108
6.3.2 工厂方法模式与IoC/DI 112
6.3.3 平行的类层次结构 115
6.3.4 参数化工厂方法 117
6.3.5 工厂方法模式的优缺点 120
6.3.6 思考工厂方法模式 121
6.3.7 相关模式 123
第7章 抽象工厂模式（Abstract Factory） 125
7.1 场景问题 126
7.1.1 选择组装电脑的配件 126
7.1.2 不用模式的解决方案 126
7.1.3 有何问题 132
7.2 解决方案 132
7.2.1 使用抽象工厂模式来解决问题 132
7.2.2 抽象工厂模式的结构和说明 133
7.2.3 抽象工厂模式示例代码 134
7.2.4 使用抽象工厂模式重写示例 136
7.3 模式讲解 140
7.3.1 认识抽象工厂模式 140
7.3.2 定义可扩展的工厂 141
7.3.3 抽象工厂模式和DAO 146
7.3.4 抽象工厂模式的优缺点 151
7.3.5 思考抽象工厂模式 151
7.3.6 相关模式 152
第8章 生成器模式（Builder） 153
8.1 场景问题 154
8.1.1 继续导出数据的应用框架 154
8.1.2 不用模式的解决方案 154
8.1.3 有何问题 161
8.2 解决方案 161
8.2.1 使用生成器模式来解决问题 161
8.2.2 生成器模式的结构和说明 162
8.2.3 生成器模式示例代码 162
8.2.4 使用生成器模式重写示例 164
8.3 模式讲解 170
8.3.1 认识生成器模式 170
8.3.2 生成器模式的实现 171
8.3.3 使用生成器模式构建复杂对象 172
8.3.4 生成器模式的优点 182
8.3.5 思考生成器模式 182
8.3.6 相关模式 183
第9章 原型模式（Prototype） 185
9.1 场景问题 186
9.1.1 订单处理系统 186
9.1.2 不用模式的解决方案 186
9.1.3 有何问题 192
9.2 解决方案 193
9.2.1 使用原型模式来解决问题 193
9.2.2 原型模式的结构和说明 194
9.2.3 原型模式示例代码 194
9.2.4 使用原型模式重写示例 196
9.3 模式讲解 200
9.3.1 认识原型模式 200
9.3.2 Java中的克隆方法 202
9.3.3 浅度克隆和深度克隆 204
9.3.4 原型管理器 211
9.3.5 原型模式的优缺点 214
9.3.6 思考原型模式 215
9.3.7 相关模式 215
第10章 中介者模式（Mediator） 217
10.1 场景问题 218
10.1.1 如果没有主板 218
10.1.2 有何问题 218
10.1.3 使用电脑来看电影 219
10.2 解决方案 219
10.2.1 使用中介者模式来解决问题 219
10.2.2 中介者模式的结构和说明 220
10.2.3 中介者模式示例代码 220
10.2.4 使用中介者模式来实现示例 223
10.3 模式讲解 230
10.3.1 认识中介者模式 230
10.3.2 广义中介者 232
10.3.3 中介者模式的优缺点 242
10.3.4 思考中介者模式 243
10.3.5 相关模式 243
第11章 代理模式（Proxy） 245
11.1 场景问题 246
11.1.1 访问多条数据 246
11.1.2 不用模式的解决方案 246
11.1.3 有何问题 250
11.2 解决方案 250
11.2.1 使用代理模式来解决问题 250
11.2.2 代理模式的结构和说明 251
11.2.3 代理模式示例代码 252
11.2.4 使用代理模式重写示例 253
11.3 模式讲解 259
11.3.1 认识代理模式 259
11.3.2 保护代理 261
11.3.3 Java中的代理 266
11.3.4 代理模式的特点 269
11.3.5 思考代理模式 269
11.3.6 相关模式 272
第12章 观察者模式（Observer） 273
12.1 场景问题 274
12.1.1 订阅报纸的过程 274
12.1.2 订阅报纸的问题 274
12.2 解决方案 275
12.2.1 使用观察者模式来解决问题 275
12.2.2 观察者模式的结构和说明 276
12.2.3 观察者模式示例代码 277
12.2.4 使用观察者模式实现示例 279
12.3 模式讲解 283
12.3.1 认识观察者模式 283
12.3.2 推模型和拉模型 285
12.3.3 Java中的观察者模式 289
12.3.4 观察者模式的优缺点 292
12.3.5 思考观察者模式 293
12.3.6 Swing 中的观察者模式 293
12.3.7 简单变形示例——区别对待观察者 294
12.3.8 相关模式 299
第13章 命令模式（Command） 301
13.1 场景问题 302
13.1.1 如何开机 302
13.1.2 与我何干 302
13.1.3 有何问题 302
13.2 解决方案 303
13.2.1 使用命令模式来解决问题 303
13.2.2 命令模式的结构和说明 304
13.2.3 命令模式示例代码 304
13.2.4 使用命令模式来实现示例 307
13.3 模式讲解 312
13.3.1 认识命令模式 312
13.3.2 参数化配置 313
13.3.3 可撤销的操作 317
13.3.4 宏命令 327
13.3.5 队列请求 333
13.3.6 日志请求 341
13.3.7 命令模式的优点 346
13.3.8 思考命令模式 347
13.3.9 退化的命令模式 347
13.3.10 相关模式 351
第14章 迭代器模式（Iterator） 353
14.1 场景问题 354
14.1.1 工资表数据的整合 354
14.1.2 有何问题 354
14.2 解决方案 354
14.2.1 使用迭代器模式来解决问题 354
14.2.2 迭代器模式的结构和说明 355
14.2.3 迭代器模式示例代码 355
14.2.4 使用迭代器模式来实现示例 359
14.3 模式讲解 368
14.3.1 认识迭代器模式 368
14.3.2 使用Java的迭代器 370
14.3.3 带迭代策略的迭代器 373
14.3.4 双向迭代器 376
14.3.5 迭代器模式的优点 379
14.3.6 思考迭代器模式 380
14.3.7 翻页迭代 381
14.3.8 相关模式 389
第15章 组合模式（Composite） 391
15.1 场景问题 392
15.1.1 商品类别树 392
15.1.2 不用模式的解决方案 392
15.1.3 有何问题 395
15.2 解决方案 396
15.2.1 使用组合模式来解决问题 396
15.2.2 组合模式的结构和说明 396
15.2.3 组合模式示例代码 397
15.2.4 使用组合模式重写示例 400
15.3 模式讲解 405
15.3.1 认识组合模式 405
15.3.2 安全性和透明性 407
15.3.3 父组件引用 409
15.3.4 环状引用 414
15.3.5 组合模式的优缺点 418
15.3.6 思考组合模式 419
15.3.7 相关模式 419
第16章 模板方法模式（Template Method） 421
16.1 场景问题 422
16.1.1 登录控制 422
16.1.2 不用模式的解决方案 422
16.1.3 有何问题 428
16.2 解决方案 428
16.2.1 使用模板方法模式来解决问题 428
16.2.2 模板方法模式的结构和说明 429
16.2.3 模板方法模式示例代码 429
16.2.4 使用模板方法模式重写示例 430
16.3 模式讲解 434
16.3.1 认识模板方法模式 434
16.3.2 模板的写法 438
16.3.3 Java回调与模板方法模式 441
16.3.4 典型应用：排序 445
16.3.5 实现通用的增删改查 449
16.3.6 模板方法模式的优缺点 463
16.3.7 思考模板方法模式 463
16.3.8 相关模式 464
第17章 策略模式（Strategy） 465
17.1 场景问题 466
17.1.1 报价管理 466
17.1.2 不用模式的解决方案 466
17.1.3 有何问题 467
17.2 解决方案 469
17.2.1 使用策略模式来解决问题 469
17.2.2 策略模式的结构和说明 470
17.2.3 策略模式示例代码 470
17.2.4 使用策略模式重写示例 472
17.3 模式讲解 475
17.3.1 认识策略模式 475
17.3.2 Context和Strategy的关系 477
17.3.3 容错恢复机制 484
17.3.4 策略模式结合模板方法模式 487
17.3.5 策略模式的优缺点 490
17.3.6 思考策略模式 492
17.3.7 相关模式 493
第18章 状态模式（State） 495
18.1 场景问题 496
18.1.1 实现在线投票 496
18.1.2 不用模式的解决方案 496
18.1.3 有何问题 498
18.2 解决方案 498
18.2.1 使用状态模式来解决问题 498
18.2.2 状态模式的结构和说明 499
18.2.3 状态模式示例代码 499
18.2.4 使用状态模式重写示例 501
18.3 模式讲解 505
18.3.1 认识状态模式 505
18.3.2 状态的维护和转换控制 509
18.3.3 使用数据库来维护状态 514
18.3.4 模拟工作流 516
18.3.5 状态模式的优缺点 527
18.3.6 思考状态模式 527
18.3.7 相关模式 528
第19章 备忘录模式（Memento） 529
19.1 场景问题 530
19.1.1 开发仿真系统 530
19.1.2 不用模式的解决方案 530
19.1.3 有何问题 533
19.2 解决方案 533
19.2.1 使用备忘录模式来解决问题 533
19.2.2 备忘录模式的结构和说明 534
19.2.3 备忘录模式示例代码 535
19.2.4 使用备忘录模式重写示例 537
19.3 模式讲解 541
19.3.1 认识备忘录模式 541
19.3.2 结合原型模式 544
19.3.3 离线存储 546
19.3.4 再次实现可撤销操作 549
19.3.5 备忘录模式的优缺点 558
19.3.6 思考备忘录模式 558
19.3.7 相关模式 559
第20章 享元模式（Flyweight） 561
20.1 场景问题 562
20.1.1 加入权限控制 562
20.1.2 不使用模式的解决方案 563
20.1.3 有何问题 568
20.2 解决方案 569
20.2.1 使用享元模式来解决问题 569
20.2.2 享元模式的结构和说明 570
20.2.3 享元模式示例代码 570
20.2.4 使用享元模式重写示例 573
20.3 模式讲解 578
20.3.1 认识享元模式 578
20.3.2 不需要共享的享元实现 580
20.3.3 对享元对象的管理 587
20.3.4 享元模式的优缺点 596
20.3.5 思考享元模式 597
20.3.6 相关模式 597
第21章 解释器模式（Interpreter） 599
21.1 场景问题 600
21.1.1 读取配置文件 600
21.1.2 不用模式的解决方案 600
21.1.3 有何问题 602
21.2 解决方案 604
21.2.1 使用解释器模式来解决问题 604
21.2.2 解释器模式的结构和说明 605
21.2.3 解释器模式示例代码 605
21.2.4 使用解释器模式重写示例 607
21.3 模式讲解 615
21.3.1 认识解释器模式 615
21.3.2 读取多个元素或属性的值 617
21.3.3 解析器 625
21.3.4 解释器模式的优缺点 633
21.3.5 思考解释器模式 633
21.3.6 相关模式 634
第22章 装饰模式（Decorator） 635
22.1 场景问题 636
22.1.1 复杂的奖金计算 636
22.1.2 简化后的奖金计算体系 636
22.1.3 不用模式的解决方案 636
22.1.4 有何问题 639
22.2 解决方案 640
22.2.1 使用装饰模式来解决问题 640
22.2.2 装饰模式的结构和说明 641
22.2.3 装饰模式示例代码 642
22.2.4 使用装饰模式重写示例 644
22.3 模式讲解 650
22.3.1 认识装饰模式 650
22.3.2 Java中的装饰模式应用 653
22.3.3 装饰模式和AOP 657
22.3.4 装饰模式的优缺点 664
22.3.5 思考装饰模式 664
22.3.6 相关模式 665
第23章 职责链模式（Chain of Responsibility） 667
23.1 场景问题 668
23.1.1 申请聚餐费用 668
23.1.2 不用模式的解决方案 668
23.1.3 有何问题 671
23.2 解决方案 671
23.2.1 使用职责链模式来解决问题 671
23.2.2 职责链模式的结构和说明 672
23.2.3 职责链模式示例代码 673
23.2.4 使用职责链模式重写示例 674
23.3 模式讲解 679
23.3.1 认识职责链模式 679
23.3.2 处理多种请求 680
23.3.3 功能链 691
23.3.4 职责链模式的优缺点 697
23.3.5 思考职责链模式 697
23.3.6 相关模式 698
第24章 桥接模式（Bridge） 701
24.1 场景问题 702
24.1.1 发送提示消息 702
24.1.2 不用模式的解决方案 702
24.1.3 有何问题 705
24.2 解决方案 707
24.2.1 使用桥接模式来解决问题 707
24.2.2 桥接模式的结构和说明 708
24.2.3 桥接模式示例代码 709
24.2.4 使用桥接模式重写示例 710
24.3 模式讲解 715
24.3.1 认识桥接模式 715
24.3.2 谁来桥接 718
24.3.3 典型例子——JDBC 721
24.3.4 广义桥接——Java中无处不桥接 723
24.3.5 桥接模式的优点 726
24.3.6 思考桥接模式 727
24.3.7 相关模式 728
第25章 访问者模式（Visitor） 731
25.1 场景问题 732
25.1.1 扩展客户管理的功能 732
25.1.2 不用模式的解决方案 734
25.1.3 有何问题 738
25.2 解决方案 739
25.2.1 使用访问者模式来解决问题 739
25.2.2 访问者模式的结构和说明 739
25.2.3 访问者模式示例代码 740
25.2.4 使用访问者模式重写示例 744
25.3 模式讲解 749
25.3.1 认识访问者模式 749
25.3.2 操作组合对象结构 751
25.3.3 谁负责遍历所有元素对象 758
25.3.4 访问者模式的优缺点 761
25.3.5 思考访问者模式 761
25.3.6 相关模式 762
附录A 常见面向对象设计原则 763
A.1 设计模式和设计原则 764
A.1.1 设计模式和设计原则的关系 764
A.1.2 为何不重点讲解设计原则 764
A.2 常见的面向对象设计原则 765
A.2.1 单一职责原则SRP（Single Responsibility Principle） 765
A.2.2 开放-关闭原则OCP（Open-Closed Principle） 765
A.2.3 里氏替换原则LSP（Liskov Substitution Principle） 765
A.2.4 依赖倒置原则DIP（Dependence Inversion Principle） 766
A.2.5 接口隔离原则ISP（Interface Segregation Principle） 766
A.2.6 最少知识原则LKP（Least Knowledge Principle） 767
A.2.7 其他原则 767
附录B UML简介 769
B.1 UML基础 770
B.1.1 UML是什么 770
B.1.2 UML历史 770
B.1.3 UML能干什么 771
B.1.4 UML有什么 771
B.2 类图 772
B.2.1 类图的概念 772
B.2.2 类图的基本表达 772
B.2.3 抽象类和接口 773
B.2.4 关系 774
B.3 顺序图 778
B.3.1 顺序图的概念 778
B.3.2 顺序图的基本表达 779
临别赠言 782
不是结束而是新的开始 782
你该怎么做 782
参考文献 783