第1章  面向对象入门 1

1.1  编程语言的几个发展阶段 1

 1.1.1  面向机器语言 1

 1.1.2  面向过程语言 1

 1.1.3  面向对象语言 2

 1.1.4  使用Java的必要性 3

1.2  从抽象到类 3

1.3  类与程序的基本结构 5

1.4  使用的开发工具 6

第2章  封装 7

2.1  从类的角度看封装性 7

 2.1.1  封装数据及操作 7

 2.1.2  类的UML图 8

2.2  从对象的角度看封装性 9

 2.2.1  创建对象所体现的封装性 9

 2.2.2  对象访问变量和调用方法所体现的封装性 11

 2.2.3  实例变量和类变量体现的封装性 12

 2.2.4  关于实例方法和类方法 13

2.3  从使用者角度看封装性 14

2.4  有理数的类封装 15

 2.4.1  Rational类 15

 2.4.2  用Rational对象做运算 18

2.5  从访问权限看封装性 19

 2.5.1  访问限制修饰符 19

 2.5.2  加强封装性 21

2.6  包与类的封装 22

 2.6.1  包封装 22

 2.6.2  引入类库中的类 24

 2.6.3  引入自定义包中的类 24

第3章  继承、接口与多态 26

3.1  子类与父类 26

3.2  子类的继承性 27

3.3  关于protected的进一步说明 27

3.4  子类对象的特点 28

3.5  隐藏继承的成员 29

3.6  通过重写实现多态 30

3.7  上转型对象体现多态 31

3.8  通过final禁止多态 33

3.9  通过super解决多态带来的问题 33

3.10  接口 34

3.11  接口回调体现的多态 36

3.12  重载体现的多态 38

第4章  组合 41

4.1  引用的重要作用 41

4.2  对象的组合 44

4.3  组合关系和依赖关系 46

4.4  组合关系是弱耦合关系 47

4.5  基于组合的流水线 48

4.6  汽车动态更换驾驶员 50

第5章  面向对象的几个基本原则 53

5.1  抽象类与接口 53

 5.1.1  抽象类 53

 5.1.2  接口 54

5.2  面向抽象原则 55

5.3 “开-闭”原则 57

 5.3.1  什么是“开-闭”原则 57

 5.3.2  标准、标准构件和面向标准的产品 58

5.4 “多用组合，少用继承”原则 61

 5.4.1  继承与复用 61

 5.4.2  组合与复用 62

 5.4.3  多用组合，少用继承 62

5.5 “高内聚-弱耦合”原则 63

第6章  设计模式简介 64

6.1  什么是设计模式 64

6.2  设计模式的起源 65

6.3  GOF之著作 65

6.4  学习设计模式的重要性 65

6.5  合理使用模式 66

6.6  什么是框架 67

6.7  模式分类 68

6.8  设计模式资源 69

第7章  策略模式 70

7.1  策略模式的结构与使用 70

 7.1.1  策略模式的结构 70

 7.1.2  策略模式的使用 74

7.2  策略模式的优点 75

7.3  适合使用策略模式的情景 75

7.4  策略模式相对继承机制的优势 76

7.5  举例——加密、解密文件 76

 7.5.1  设计要求 76

 7.5.2  设计实现 76

第8章  状态模式 82

8.1  状态模式的结构与使用 82

 8.1.1  状态模式的结构 82

 8.1.2  状态模式的使用 85

8.2  状态切换 86

8.3  状态模式的优点 89

8.4  适合使用状态模式的情景 89

8.5  举例——模拟咖啡自动售货机 89

 8.5.1  设计要求 89

 8.5.2  设计实现 90

第9章  命令模式 93

9.1  命令模式的结构与使用 93

 9.1.1  命令模式的结构 93

 9.1.2  命令模式的使用 97

9.2  命令接口中的撤销方法 98

9.3  命令模式的优点 101

9.4  适合使用命令模式的情景 101

9.5  举例——控制电灯 101

 9.5.1  设计要求 101

 9.5.2  设计实现 101

第10章  中介者模式 105

10.1  中介者模式的结构与使用 105

 10.1.1  中介者模式的结构 105

 10.1.2  中介者模式的使用 108

10.2  中介者模式的优点 110

10.3  适合使用中介者模式的情景 110

10.4  举例——组件交互 110

 10.4.1  设计要求 110

 10.4.2  设计实现 111

第11章  责任链模式 114

11.1  责任链模式的结构与使用 114

 11.1.1  责任链模式的结构 114

 11.1.2  责任链模式的使用 118

11.2  责任链模式的优点 118

11.3  适合使用责任链模式的情景 119

11.4  举例——计算阶乘 119

 11.4.1  设计要求 119

 11.4.2  设计实现 119

第12章  模板方法模式 123

12.1  模板方法模式的结构与使用 123

 12.1.1  模板方法模式的结构 123

 12.1.2  模板方法模式的使用 126

12.2  钩子方法 127

12.3  模板方法模式的优点 130

12.4  适合使用模板方法模式的情景 130

12.5  举例——考试与成绩录入 130

 12.5.1  设计要求 130

 12.5.2  设计实现 131

第13章  观察者模式 135

13.1  观察者模式的结构与使用 135

 13.1.1  观察者模式的结构 135

 13.1.2  观察者模式的使用 140

13.2  观察者模式中的“推”数据与“拉”数据 141

13.3  观察者模式的优点 144

13.4  适合使用观察者模式的情景 145

13.5  举例——关注天气和旅游信息 145

 13.5.1  设计要求 145

 13.5.2  设计实现 145

第14章  访问者模式 150

14.1  访问者模式的结构与使用 150

 14.1.1  访问者模式的结构 150

 14.1.2  访问者模式的使用 153

14.2  双重分派 154

14.3  访问者模式的优点 154

14.4  适合使用访问模式的情景 155

14.5  举例——评价体检表 155

 14.5.1  设计要求 155

 14.5.2  设计实现 155

第15章  装饰模式 160

15.1  装饰模式的结构与使用 160

 15.1.1  装饰模式的结构 160

 15.1.2  装饰模式的使用 163

15.2  使用多个装饰者 164

15.3  装饰模式相对继承机制的优势 165

15.4  装饰模式的优点 166

15.5  适合使用装饰模式的情景 166

15.6  举例——读取单词表 166

 15.6.1  设计要求 166

 15.6.2  设计实现 167

第16章  组合模式 171

16.1  组合模式的结构与使用 171

 16.1.1  组合模式的结构 171

 16.1.2  组合模式的使用 174

16.2  组合模式的优点 176

16.3  适合使用组合模式的情景 176

16.4  举例——苹果树的重量及苹果的价值 176

 16.4.1  设计要求 176

 16.4.2  设计实现 177

第17章  适配器模式 180

17.1  适配器模式的结构与使用 180

 17.1.1  适配器模式的结构 180

 17.1.2  适配器模式的使用 182

 17.1.3  适配器的适配程度 183

17.2  适配器模式的优点 184

17.3  适合使用适配器模式的情景 184

17.4  单接口适配器 184

17.5  举例——Iterator接口与Enumeration接口 185

 17.5.1  设计要求 185

 17.5.2  设计实现 185

第18章  外观模式 188

18.1  外观模式的结构与使用 188

 18.1.1  外观模式的结构 188

 18.1.2  外观模式的使用 190

18.2  外观模式的优点 191

18.3  适合使用外观模式的情景 191

18.4  举例——解析文件 191

 18.4.1  设计要求 191

 18.4.2  设计实现 192

第19章  代理模式 195

19.1  代理模式的结构与使用 195

 19.1.1  代理模式的结构 195

 19.1.2  代理模式的使用 197

19.2  远程代理 198

 19.2.1  RMI与代理模式 198

 19.2.2  RMI的设计细节 199

19.3  代理模式的优点 203

19.4  适合使用代理模式的情景 203

19.5  举例——使用远程窗口阅读文件 203

 19.5.1  设计要求 203

 19.5.2  设计实现 203

第20章  享元模式 207

20.1  享元模式的结构与使用 207

 20.1.1  享元模式的结构 207

 20.1.2  享元模式的使用 212

20.2  享元模式的优点 213

20.3  适合使用享元模式的情景 213

20.4  举例——化合物 213

 20.4.1  设计要求 213

 20.4.2  设计实现 214

第21章  桥接模式 218

21.1  桥接模式的结构与使用 218

 21.1.1  桥接模式的结构 218

 21.1.2  桥接模式的使用 221

21.2  桥接模式的优点 222

21.3  适合使用桥接模式的情景 222

21.4  举例——模拟电视节目 222

 21.4.1  设计要求 222

 21.4.2  设计实现 222

第22章  工厂方法模式 226

22.1  工厂方法模式的结构与使用 226

 22.1.1  工厂方法模式的结构 226

 22.1.2  工厂方法模式的使用 229

22.2  工厂方法模式的优点 230

22.3  适合使用工厂方法模式的情景 231

22.4  举例——药品 231

 22.4.1  设计要求 231

 22.4.2  设计实现 231

第23章  抽象工厂模式 235

23.1  抽象工厂模式的结构与使用 235

 23.1.1  抽象工厂模式的结构 235

 23.1.2  抽象工厂模式的使用 240

23.2  工厂方法模式的优点 241

23.3  适合使用抽象工厂模式的情景 242

23.4  举例——商店与西服、牛仔服 242

 23.4.1  设计要求 242

 23.4.2  设计实现 242

 23.4.3  模式的使用 245

第24章  生成器模式 247

24.1  生成器模式的结构与使用 247

 24.1.1  生成器模式的结构 247

 24.1.2  生成器模式的使用 250

24.2  生成器模式的优点 251

24.3  适合使用生成器模式的情景 252

24.4  举例——日历牌 252

 24.4.1  设计要求 252

 24.4.2  设计实现 252

第25章  原型模式 259

25.1  java.lang.Object类的clone方法 259

25.2  Serializable接口与克隆对象 263

25.3  原型模式的结构与使用 263

 25.3.1  原型模式的结构 263

 25.3.2  原型模式的使用 265

25.4  原型模式的优点 266

25.5  适合使用原型模式的情景 266

25.6  举例——克隆容器 267

 25.6.1  设计要求 267

 25.6.2  设计实现 267

第26章  单件模式 270

26.1  单件模式的结构与使用 270

 26.1.1  单件模式的结构 270

 26.1.2  单件模式的使用 272

26.2  单件模式的优点 273

26.3  适合使用单件模式的情景 273

26.4  举例——冠军 273

 26.4.1  设计要求 273

 26.4.2  设计实现 273

参考文献 278

??

??

??

??

面向对象与设计模式

目录