第1部分 适应设计模式  1
         第1章 Iterator模式——一个一个遍历  1
         1.1 Iterator模式  2
         1.2 示例程序  2
         Aggregate接口  3
         Iterator接口  5
         Book类  5
         BookShelf类  5
         BookShelfIteraotr类  6
         Main类  7
         1.3 Iterator模式中的登场角色  8
         1.4 拓展思路的要点  9
         不管实现如何变化,都可以使用Iterator  9
         难以理解抽象类和接口  9
         Aggregate和Iterator的对应  9
         容易弄错“下一个”  10
         还容易弄错“最后一个”  10
         多个Iterator  10
         迭代器的种类多种多样  10
         不需要deleteIterator  10
         1.5 相关的设计模式  11
         1.6 本章所学知识  11
         1.7 练习题  11
         第2章 Adapter模式——加个“适配器”以便于复用  13
         2.1 Adapter模式  14
         2.2 示例程序(1)(使用继承的适配器)  14
         Banner类  15
         Print接口  16
         PrintBanner类  16
         Main类  16
         2.3 示例程序(2)(使用委托的示例程序)  17
         Print类  18
         PrintBanner类  18
         2.4 Adapter模式中的登场角色  18
         2.5 拓展思路的要点  19
         什么时候使用Adapter模式  19
         如果没有现成的代码  20
         版本升级与兼容性  20
         功能完全不同的类  20
         2.6 相关的设计模式  20
         2.7 本章所学知识  21
         2.8 练习题  21
         第2部分 交给子类  23
         第3章 Template Method模式——将具体处理交给子类  23
         3.1 Template Method模式  24
         什么是模板  24
         什么是Template Method模式  24
         3.2 示例程序  24
         AbstractDisplay类  25
         CharDisplay类  26
         StringDisplay类  27
         Main类  28
         3.3 Template Method模式中的登场角色  28
         3.4 拓展思路的要点  29
         可以使逻辑处理通用化  29
         父类与子类之间的协作  29
         父类与子类的一致性  29
         3.5 相关的设计模式  30
         3.6 延伸阅读:类的层次与抽象类  30
         父类对子类的要求  30
         抽象类的意义  30
         父类与子类之间的协作  31
         3.7 本章所学知识  31
         3.8 练习题  31
         第4章 Factory Method模式——将实例的生成交给子类  33
         4.1 Factory Method模式  34
         4.2 示例程序  34
         Product类  35
         Factory类  35
         IDCard类  36
         IDCardFactory类  36
         Main类  37
         4.3 Factory Method模式中的登场角色  37
         4.4 拓展思路的要点  39
         框架与具体加工  39
         生成实例——方法的三种实现方式  39
         使用模式与开发人员之间的沟通  40
         4.5 相关的设计模式  40
         4.6 本章所学知识  41
         4.7 练习题  41
         第3部分 生成实例  43
         第5章 Singleton模式——只有一个实例  43
         5.1 Singleton模式  44
         5.2 示例程序  44
         Singleton类  44
         Main类  45
         5.3 Singleton模式中的登场角色  46
         5.4 拓展思路的要点  46
         为什么必须设置限制  46
         何时生成这个唯一的实例  46
         5.5 相关的设计模式  47
         5.6 本章所学知识  47
         5.7 练习题  47
         第6章 Prototype模式——通过复制生成实例  49
         6.1 Prototype模式  50
         6.2 示例程序  50
         Product接口  51
         Manager类  52
         MessageBox类  52
         UnderlinePen类  53
         Main类  54
         6.3 Prototype模式中的登场角色  55
         6.4 拓展思路的要点  56
         不能根据类来生成实例吗  56
         类名是束缚吗  56
         6.5 相关的设计模式  57
         6.6 延伸阅读:clone方法和java.lang.Clonable接口  57
         Java语言的clone  57
         clone方法是在哪里定义的  58
         需要实现Cloneable的哪些方法  58
         clone方法进行的是浅复制  58
         6.7 本章所学知识  58
         6.8 练习题  59
         第7章 Builder模式——组装复杂的实例  61
         7.1 Builder模式  62
         7.2 示例程序  62
         Builder类  63
         Director类  63
         TextBuilder类  64
         HTMLBuilder类  65
         Main类  65
         7.3 Builder模式中的登场角色  67
         7.4 相关的设计模式  69
         7.5 拓展思路的要点  69
         谁知道什么  69
         设计时能够决定的事情和不能决定的事情  70
         代码的阅读方法和修改方法  70
         7.6 本章所学知识  70
         7.7 练习题  70
         第8章 Abstract Factory模式——将关联零件组装成产品  73
         8.1 Abstract Factory模式  74
         8.2 示例程序  74
         抽象的零件:Item类  77
         抽象的零件:Link类  78
         抽象的零件:Tray类  78
         抽象的产品:Page类  79
         抽象的工厂:Factory类  79
         使用工厂将零件组装称为产品:Main类  80
         具体的工厂:ListFactory类  81
         具体的零件:ListLink类  82
         具体的零件:ListTray类  82
         具体的产品:ListPage类  83
         8.3 为示例程序增加其他工厂  84
         具体的工厂:TableFactory类  85
         具体的零件:TableLink类  86
         具体的零件:TableTray类  86
         具体的产品:TablePage类  87
         8.4 Abstract Factory模式中的登场角色  87
         8.5 拓展思路的要点  89
         易于增加具体的工厂  89
         难以增加新的零件  89
         8.6 相关的设计模式  89
         8.7 延伸阅读:各种生成实例的方法的介绍  90
         8.8 本章所学知识  91
         8.9 练习题  91
         第4部分 分开考虑  93
         第9章 Bridge模式——将类的功能层次结构与实现层次结构分离  93
         9.1 Bridge模式  94
         9.2 示例程序  95
         类的功能层次结构:Display类  96
         类的功能层次结构:CountDisplay类  97
         类的实现层次结构:DisplayImpl类  97
         类的实现层次结构:StringDisplayImpl类  98
         Main类  98
         9.3 Bridge模式中的登场角色  99
         9.4 拓展思路的要点  100
         分开后更容易扩展  100
         继承是强关联,委托是弱关联  100
         9.5 相关的设计模式  101
         9.6 本章所学知识  101
         9.7 练习题  102
         第10章 Strategy模式——整体地替换算法  103
         10.1 Strategy模式  104
         10.2 示例程序  104
         Hand类  105
         Strategy接口  106
         WinningStrategy类  106
         ProbStrategy类  107
         Player类  109
         Main类  109
         10.3 Strategy模式中的登场角色  111
         10.4 拓展思路的要点  112
         为什么需要特意编写Strategy角色  112
         程序运行中也可以切换策略  112
         10.5 相关的设计模式  113
         10.6 本章所学知识  113
         10.7 练习题  113
         第5部分 一致性  117
         第11章 Composite模式——容器与内容的一致性  117
         11.1 Composite模式  118
         11.2 示例程序  118
         Entry类  119
         File类  120
         Directory类  121
         FileTreatMentException类  122
         Main类  122
         11.3 Composite模式中的登场角色  124
         11.4 拓展思路的要点  125
         多个和单个的一致性  125
         Add方法应该放在哪里  126
         到处都存在递归结构  126
         11.5 相关的设计模式  126
         11.6 本章所学知识  127
         11.7 练习题  127
         第12章 Decorator模式——装饰边框与被装饰物的一致性  129
         12.1 Decorator模式  130
         12.2 示例程序  130
         Display类  131
         StringDisplay类  132
         Border类  132
         SideBorder类  133
         FullBorder类  134
         Main类  135
         12.3 Decorator模式中的登场角色  136
         12.4 拓展思路的要点  137
         接口(API)的透明性  137
         在不改变被装饰物的前提下增加功能  138
         可以动态地增加功能  138
         只需要一些装饰物即可添加许多功能  138
         java.io包与Decorator模式  138
         导致增加许多很小的类  139
         12.5 相关的设计模式  139
         12.6 延伸阅读:继承和委托中的一致性  140
         继承——父类和子类的一致性  140
         委托——自己和被委托对象的一致性  140
         12.7 本章所学知识  142
         12.8 练习题  142
         第6部分 访问数据结构  145
         第13章 Visitor模式——访问数据结构并处理数据  145
         13.1 Visitor模式  146
         13.2 示例程序  146
         Visitor类  147
         Element接口  148
         Entry类  148
         File类  148
         Directory类  149
         ListVisitor类  150
         FileTreatmentException类  151
         Main类  151
         Visitor与Element之间的相互调用  152
         13.3 Visitor模式中的登场角色  154
         13.4 拓展思路的要点  155
         双重分发  155
         为什么要弄得这么复杂  155
         开闭原则——对扩展开放,对修改关闭  155
         易于增加ConcreteVisitor角色  156
         难以增加ConcreteElement角色  156
         Visitor工作所需的条件  156
         13.5 相关的设计模式  157
         13.6 本章所学知识  157
         13.7 练习题  157
         第14章 Chain of Responsibility模式——推卸责任  161
         14.1 Chain of Responsibility模式  162
         14.2 示例程序  162
         Trouble类  163
         Support类  163
         NoSupport类  164
         LimitSupport类  164
         OddSupport类  165
         SpecialSupport类  165
         Main类  166
         14.3 Chain of Responsibility模式中的登场角色  167
         14.4 拓展思路的要点  168
         弱化了发出请求的人和处理请求的人之间的关系  168
         可以动态地改变职责链  168
         专注于自己的工作  169
         推卸请求会导致处理延迟吗  169
         14.5 相关的设计模式  169
         14.6 本章所学知识  169
         14.7 练习题  169
         第7部分 简单化  171
         第15章 Facade模式——简单窗口  171
         15.1 Facade模式  172
         15.2 示例程序  172
         Database类  173
         HtmlWriter类  174
         PageMaker类  175
         Main类  176
         15.3 Facade模式中的登场角色  176
         15.4 拓展思路的要点  177
         Facade角色到底做什么工作  177
         递归地使用Facade模式  178
         开发人员不愿意创建Facade角色的原因——心理原因  178
         15.5 相关的设计模式  178
         15.6 本章所学知识  178
         15.7 练习题  179
         第16章 Mediator模式——只有一个仲裁者  181
         16.1 Mediator模式  182
         16.2 示例程序  182
         Mediator接口  185
         Colleague接口  186
         ColleagueButton类  186
         ColleagueTextField类  187
         ColleagueCheckbox类  188
         LoginFrame类  188
         Main类  191
         16.3 Mediator模式中的登场角色  191
         16.4 拓展思路的要点  192
         当发生分散灾难时  192
         通信线路的增加  193
         哪些角色可以复用  193
         16.5 相关的设计模式  193
         16.6 本章所学知识  193
         16.7 练习题  194
         第8部分 管理状态  195
         第17章 Observer模式——发送状态变化通知  195
         17.1 Observer模式  196
         17.2 示例程序  196
         Observer接口  196
         NumberGenerator类  197
         RandomNumberGenerator类  198
         DigitObserver类  198
         GraphObserver类  199
         Main类  199
         17.3 Observer模式中的登场角色  200
         17.4 拓展思路的要点  201
         这里也出现了可替换性  201
         Observer的顺序  202
         当Observer的行为会对Subject产生影响时  202
         传递更新信息的方式  202
         从“观察”变为“通知”  203
         Model/View/Controller(MVC)  203
         17.5 延伸阅读:java.util.Observer接口  203
         17.6 相关的设计模式  204
         17.7 本章所学知识  204
         17.8 练习题  204
         第18章 Memento模式——保存对象状态  207
         18.1 Memento模式  208
         18.2 示例程序  208
         Memento类  209
         Gamer类  210
         Main类  211
         18.3 Memento模式中的登场角色  215
         18.4 拓展思路的要点  216
         两种接口(API)和可见性  216
         需要多少个Memento  217
         Memento的有效期限是多久  217
         划分Caretaker角色和Originator角色的意义  217
         18.5 相关的设计模式  218
         18.6 本章所学知识  218
         18.7 练习题  218
         第19章 State模式——用类表示状态  221
         19.1 State模式  222
         19.2 示例程序  222
         金库警报系统  222
         不使用State模式的伪代码  223
         使用了State模式的伪代码  224
         State接口  226
         DayState类  226
         NightState类  227
         Context接口  228
         SafeFrame类  228
         Main类  231
         19.3 State模式中的登场角色  232
         19.4 拓展思路的要点  233
         分而治之  233
         依赖于状态的处理  233
         应当是谁来管理状态迁移  233
         不会自相矛盾  234
         易于增加新的状态  234
         实例的多面性  235
         19.5 相关的设计模式  235
         19.6 本章所学知识  235
         19.7 练习题  236
         第9部分 避免浪费  237
         第20章 Flyweight模式——共享对象,避免浪费  237
         20.1 Flyweight模式  238
         20.2 示例程序  238
         BigChar类  240
         BigCharFactory类  241
         BigString类  242
         Main类  244
         20.3 Flyweight模式中的登场角色  244
         20.4 拓展思路的要点  245
         对多个地方产生影响  245
         Intrinsic与Extrinsic  246
         不要让被共享的实例被垃圾回收器回收了  246
         内存之外的其他资源  247
         20.5 相关的设计模式  247
         20.6 本章所学知识  247
         20.7 练习题  247
         第21章 Proxy模式——只在必要时生成实例  249
         21.1 Proxy模式  250
         21.2 示例程序  250
         Printer类  251
         Printable接口  252
         PrinterProxy类  253
         Main类  254
         21.3 Proxy模式中的登场角色  254
         21.4 拓展思路的要点  255
         使用代理人来提升处理速度  255
         有必要划分代理人和本人吗  256
         代理与委托  256
         透明性  256
         HTTP代理  256
         各种Proxy模式  257
         21.5 相关的设计模式  257
         21.6 本章所学知识  257
         21.7 练习题  257
         第10部分 用类来表现  259
         第22章 Command模式——命令也是类  259
         22.1 Command模式  260
         22.2 示例程序  260
         Command接口  261
         MacroCommand类  262
         DrawCommand类  263
         Drawable接口  263
         DrawCanvas类  264
         Main类  265
         22.3 Command模式中的登场角色  268
         22.4 拓展思路的要点  269
         命令中应该包含哪些信息  269
         保存历史记录  269
         适配器  269
         22.5 相关的设计模式  271
         22.6 本章所学知识  272
         22.7 练习题  272
         第23章 Interpreter模式——语法规则也是类  273
         23.1 Interpreter模式  274
         23.2 迷你语言  274
         迷你语言的命令  274
         迷你语言程序示例  275
         迷你语言的语法  278
         终结符表达式与非终结符表达式  279
         23.3 示例程序  279
         Node类  281
         ProgramNode类  281
         CommandListNode类  282
         CommandNode类  283
         RepeatCommandNode类  284
         PrimitiveCommandNode类  285
         Context类  285
         ParseException类  286
         Main类  287
         23.4 Interpreter模式中的登场角色  288
         23.5 拓展思路的要点  289
         还有其他哪些迷你语言  289
         跳过标记还是读取标记  290
         23.6 相关的设计模式  290
         23.7 本章所学知识以及本书的结束语  290
         23.8 练习题  290
         附录  293
         附录A 习题解答  294
         附录B 示例程序的运行步骤  359
         附录C GoF对设计模式的分类  361
         附录D 设计模式Q&A  362
         附录E 参考书籍  365
      · · · · · ·     (
收起)