面向对象开发参考手册

图书目录:

目　录

第 1章　转变观念　1

1.1　传统的面向对象　1

1.2　重新认识对象　4

1.3　如何分解对象？　6

1.4　如何设计对象？　8

1.5　设计对象的接口　9

1.6　改进对象的继承　12

1.7　设计抽象的系统　13

1.8　设计美的系统　13

第 2章　经典模式　15

2.1　设计模式的基本原则　18

2.2　抽象工厂模式(Abstract Factory)　18

2.3　抽象服务模式(Abstract Server)　19

2.4　无环访问者模式(Acyclic Visitor)　20

2.5　适配器模式(Adapter)　21

2.6　桥接模式(Bridge)　22

2.7　生成器模式(Builder)　23

2.8　职责链模式(Chain of Responsibility)　24

2.9　命令模式(Command)　25

2.10　组合模式(Composite)　26

2.11　装饰模式(Decorator)　27

2.12　扩展对象模式(Extension Object)　28

2.13　外观模式(Fa?ade)　29

2.14　工厂方法模式(Factory Method)　29

2.15　享元模式(Flyweight)　30

2.16　解释器模式(Interpreter)　31

2.17　迭代器模式(Iterator)　32

2.18　中介者模式(Mediator)　33

2.19　备忘录模式(Memento)　34

2.20　空对象模式(Null Object)　35

2.21　观察者模式(Observer)　36

2.22　原型模式(Prototype)　37

2.23　代理模式(Proxy)　38

2.24　数量模式(Quantity)　39

2.25　范围模式(Range)　40

2.26　单件模式(Singleton)　41

2.27　规格模式(Specification)　41

2.28　状态模式(State)　42

2.29　策略模式(Strategy)　43

2.30　模板方法模式(Template Method)　44

2.31　访问者模式(Visitor)　45

2.32　设计模式应用的综合例子　47

第3章　敏捷软件　51

3.1　基本原则　52

3.1.1　对象设计原则　53

3.1.2　包的设计原则　56

3.2　敏捷建模　59

3.2.1　关于建模的一些认识误区　60

3.2.2　敏捷建模的原则和实践　60

3.3　按意图编程　61

3.3.1　名字：选择语义清晰的名字　62

3.3.2　简单：做**简单但又能工作的事情　62

3.3.3　假设：做有根据的假设　62

3.3.4　注释：“不要注释”　63

3.4　软件的度量　63

3.4.1　对象的度量　63

3.4.2　包的度量　64

3.4.3　测试的度量　65

3.5　延伸阅读：源代码就是设计　66

第4章　测试驱动　75

4.1　什么是TDD　75

4.1.1　测试原则：尽早、经常、自动化　76

4.1.2　验收测试　78

4.1.3　模拟对象　78

4.2　测试技巧　79

4.2.1　测试之前的思想准备　79

4.2.2　测试之间的关系——相互独立的测试　80

4.2.3　什么时候写测试　80

4.2.4　如何开始写测试——断言优先　80

4.2.5　如何选择测试数据——显然数据　81

4.2.6　测试如何组织——测试列表　81

4.2.7　测试哪些东西　82

4.2.8　简单的测试　84

4.2.9　易读的测试　84

4.2.10　可维护的测试　84

4.2.11　可运行的测试　85

4.2.12　可调试的测试　86

4.2.13　测试的初始化　86

4.2.14　使用断言的消息参数　87

4.2.15　使用代码覆盖率工具　87

4.2.16　测试代码也要不断重构　87

4.3　开发工具的测试框架　88

第5章　重构方法　91

5.1　软件的味道　92

5.1.1　重复代码　93

5.1.2　过长方法　94

5.1.3　过大类　94

5.1.4　过长参数列表　95

5.1.5　发散变化　96

5.1.6　霰弹式手术　96

5.1.7　依恋情结(交往不当)　96

5.1.8　数据泥团　97

5.1.9　基本类型偏执　97

5.1.10　switch语句　98

5.1.11　平行继承体系　99

5.1.12　冗赘类　99

5.1.13　夸夸其谈的未来性　100

5.1.14　令人迷惑的临时字段　100

5.1.15　过度耦合的消息链　101

5.1.16　中间转手人　101

5.1.17　狎昵关系　102

5.1.18　异曲同工的类　102

5.1.19　不完善的程序库类　102

5.1.20　数据类　103

5.1.21　被拒绝的遗赠　103

5.1.22　不当注释　104

5.1.23　过于复杂的条件逻辑　105

5.1.24　不恰当的暴露　105

5.1.25　解决方案蔓延　105

5.1.26　组合爆炸　106

5.1.27　怪异的解决方案　106

5.2　如何开始重构　106

5.2.1　什么时候重构　106

5.2.2　什么时候不能重构　107

5.2.3　怎样开始重构——掌握好重构的节奏　107

5.3　重构方法索引　108

5.4　重新组织方法　111

5.4.1　提炼方法　111

5.4.2　内联方法　112

5.4.3　内联临时变量　112

5.4.4　引入解释变量　113

5.4.5　移除对参数的赋值　113

5.4.6　用方法对象替代方法　114

5.4.7　用查询替代临时变量　114

5.4.8　分解临时变量　115

5.4.9　替换算法　115

5.5　在对象间迁移特性　116

5.5.1　提炼类　116

5.5.2　隐藏委托　116

5.5.3　内联类　117

5.5.4　引入外加方法　117

5.5.5　引入本地扩展　118

5.5.6　迁移字段　118

5.5.7　迁移方法　119

5.5.8　移除中间人　120

5.6　重新组织数据　120

5.6.1　双向关联改为单向关联　120

5.6.2　引用对象改为值对象　121

5.6.3　单向关联改为双向关联　122

5.6.4　值对象改为引用对象　122

5.6.5　复制被观察的数据　123

5.6.6　封装集合　123

5.6.7　封装字段　124

5.6.8　用对象替代数组　124

5.6.9　用对象替代数据值　125

5.6.10　用符号常数替代魔幻数字　126

5.6.11　用数据类替代记录　126

5.6.12　用字段替代子类　126

5.6.13　用类替代类型码　127

5.6.14　用状态/策略模式替代类型码　128

5.6.15　用子类替代类型码　128

5.6.16　自封装字段　129

5.7　简化条件表达式　130

5.7.1　合并条件表达式　130

5.7.2　合并重复的条件片断　131

5.7.3　分解条件式　131

5.7.4　引入断言　131

5.7.5　引入空对象　132

5.7.6　移除控制标志　133

5.7.7　用命令模式替代条件调度　133

5.7.8　用策略模式替代条件逻辑　134

5.7.9　用多态替代条件式　135

5.7.10　用卫述语句替代嵌套条件式　135

5.7.11　用状态模式替代状态改变条件式　136

5.8　简化方法调用　137

5.8.1　增加参数　138

5.8.2　构造函数链　138

5.8.3　组合方法　139

5.8.4　封装向下转型　139

5.8.5　隐藏方法　140

5.8.6　引入参数对象　140

5.8.7　把聚集操作迁移到收集参数　141

5.8.8　把聚集操作迁移到访问者模式　141

5.8.9　把装饰功能迁移到装饰者模式　143

5.8.10　参数化方法　144

5.8.11　保持对象完整　145

5.8.12　移除参数　145

5.8.13　移除设置方法　146

5.8.14　重命名方法　146

5.8.15　用工厂方法替代构造函数　146

5.8.16　用异常替代错误码　147

5.8.17　用测试替代异常　147

5.8.18　用组合模式替代隐含树　148

5.8.19　用明确方法替代参数　149

5.8.20　用方法替代参数　149

5.8.21　分离查询和修改　150

5.9　处理概括关系　151

5.9.1　折叠继承体系　151

5.9.2　提炼适配器模式　152

5.9.3　提炼组合模式　153

5.9.4　提炼接口　153

5.9.5　提炼子类　154

5.9.6　提炼超类　155

5.9.7　塑造模板方法模式　155

5.9.8　上移构造函数　156

5.9.9　上移字段　157

5.9.10　上移方法　157

5.9.11　下移字段　157

5.9.12　下移方法　158

5.9.13　用继承替代委托　158

5.9.14　用观察者模式替代硬编码通知　159

5.9.15　用解释器模式替代隐式语言　160

5.9.16　用委托替代继承　161

5.9.17　用组合模式替代一/多之分　162

5.9.18　统一接口　163

5.9.19　用适配器模式统一接口　163

5.10　封装对象的创建　164

5.10.1　用工厂封装类　164

5.10.2　用生成器模式封装组合模式　165

5.10.3　提炼参数　166

5.10.4　内联单件模式　166

5.10.5　用工厂方法引入多态创建　167

5.10.6　用单件模式限制实例化　167

5.10.7　把创建知识迁移到工厂　168

5.10.8　用创建方法替代构造函数　169

5.11　大型重构　169

5.11.1　过程化设计转化为对象设计　170

5.11.2　提炼继承体系　170

5.11.3　分离域和表示层　171

5.11.4　梳理分解继承体系　172

第6章　领域模型　173

6.1　目标　175

6.1.1　消化知识　176

6.1.2　交流语言　177

6.1.3　模型和代码绑定　178

6.2　基本构件　179

6.2.1　分离领域　180

6.2.2　关联　182

6.2.3　实体　183

6.2.4　值对象　183

6.2.5　服务　184

6.2.6　模块(包)　185

6.2.7　聚合　186

6.2.8　工厂　189

6.2.9　仓储　191

6.3　深层模型　195

6.4　挖掘隐含概念　196

6.4.1　概念挖掘　196

6.4.2　显式约束　197

6.4.3　作为领域对象的流程　198

6.4.4　规格模式　199

6.5　柔性设计　204

6.5.1　释义接口　205

6.5.2　无副作用函数　207

6.5.3　断言　208

6.5.4　概念轮廓　209

6.5.5　孤立类　210

6.5.6　操作封闭　210

6.5.7　声明性设计　211

6.6　战略性设计　214

6.7　限界上下文　215

6.7.1　持续集成　218

6.7.2　上下文映射　219

6.7.3　共享内核　219

6.7.4　客户/供应商开发团队　220

6.7.5　同流者　220

6.7.6　防腐层　220

6.7.7　隔离方式　221

6.7.8　开放主机服务　222

6.7.9　公布语言　222

6.8　模型精炼　222

6.8.1　核心领域　223

6.8.2　通用子域　224

6.8.3　领域愿景声明　225

6.8.4　突出核心　225

6.8.5　内聚机制　226

6.8.6　隔离核心　227

6.8.7　抽象核心　227

6.9　大比例结构　228

6.9.1　渐进顺序　230

6.9.2　系统隐喻　230

6.9.3　职责层　231

6.9.4　知识级别　232

6.9.5　插件框架　235

第7章　敏捷过程　237

7.1　敏捷宣言　237

7.2　敏捷过程的原则　238

7.3　典型的敏捷过程　240

7.3.1　计划　240

7.3.2　测试　241

7.3.3　重构　244

7.4　敏捷实践　245

7.4.1　基本实践　245

7.4.2　扩展实践　247

第8章　应用实践　249

8.1　培养敏感性　249

8.2　统一版本(产品化)　250

8.3　从数据模型中心到领域模型中心　251

8.3.1　让领域对象封装数据结构　251

8.3.2　O-R映射　252

8.3.3　推迟数据库和UI的实现　253

8.4　使用通用语言建模　253

8.5　分离接口与实现　254

8.6　区分职责与功能　254

8.7　提炼知识　255

8.8　消除基本类型偏执　256

8.9　合理划分对象　257

8.10　牢记测试先行　257

写在**后　259