面向对象编程导论 原书第3版PDF电子书下载

1.1 为什么OOP这么流行 1

第1章 面向对象思想 1

1.2 语言和思维 2

1.2.1 爱斯基摩人和雪 2

1.2.2 关于计算机语言的一个例子 2

1.2.3 丘奇猜想和沃夫假说 4

1.3 一个新的范例 5

1.4 一种观察世界的方式 6

1.4.1 代理和团体 6

1.4.2 消息和方法 7

1.4.4 类和实例 8

1.4.5 类的层次——继承 8

1.4.3 责任 8

1.4.6 方法绑定与改写 10

1.4.7 面向对象概念总结 10

1.5 模拟计算 11

1.5.1 隐喻的力量 11

1.5.2 避免无限回归 12

1.6 一段简史 13

小结 13

进一步阅读材料 14

自学提问 16

练习 16

第2章 抽象 17

2.1 抽象层次 18

2.2 抽象的其他形式 20

2.2.2 封装和互换性 21

2.2.1 部分分化 21

2.2.3 接口和实现 22

2.2.4 服务视角 22

2.2.5 复合法 23

2.2.6 特化分层 24

2.2.7 模式 26

2.3 抽象机制的发展简史 26

2.3.1 汇编语言 26

2.3.2 过程 27

2.3.3 模块 28

2.3.4 抽象数据类型 29

2.3.5 以服务为中心的观点 30

2.3.6 消息、继承和多态 30

小结 30

进一步阅读材料 31

自学提问 32

练习 32

第3章 面向对象设计 33

3.1 责任意味着无干扰 33

3.2 小项目编程与大项目编程 34

3.3 为什么从行为开始 34

3.4 一个RDD实例 35

3.4.1 交互式智能厨房助手 35

3.4.2 通过场景工作 36

3.4.3 组件的标识 36

3.5 CRC卡——记录责任 37

3.5.1 给组件一个物理表示 37

3.5.2 “什么/谁”循环 37

3.6 组件和行为 38

3.5.3 文档 38

3.6.1 延迟决定 39

3.6.2 为变化做准备 39

3.6.3 继续场景 40

3.6.4 交互图表 41

3.7 软件组件 42

3.7.1 行为和状态 42

3.7.2 实例和类 42

3.7.3 耦合性和内聚性 43

3.7.4 接口和实现——Parnas原则 43

3.8 形式化接口 44

3.9 设计表现 45

3.10 实现组件 45

3.12 维护和升级 46

3.11 组件集成 46

小结 47

进一步阅读材料 47

自学提问 47

练习 48

第4章 类和方法 49

4.1 封装 49

4.2 类定义 50

4.2.1 C++、Java和C#语言 50

4.2.2 Apple Object Pascal和Delphi Pascal语言 51

4.2.3 Smalltalk语言 52

4.2.4 其他语言 53

4.3 方法 54

4.3.2 常量或不可变数据字段 56

4.3.1 类中方法的声明次序 56

4.3.3 定义和实现的分离 57

4.4 关于类主题的变化 60

4.4.1 Oberon语言中不属于类的方法 60

4.4.2 接口 61

4.4.3 属性 61

4.4.4 向前定义 62

4.4.5 内部类(或嵌套类) 63

4.4.6 类的数据字段 66

4.4.7 作为对象的类 67

小结 68

进一步阅读材料 68

练习 69

自学提问 69

第5章 消息、实例和初始化 71

5.1 消息传递语法 71

5.2 静态类型语言和动态类型语言 72

5.3 从方法内部存取接收器 73

5.4 对象的创建 75

5.5 指针和内存分配 76

5.6 构造函数 79

5.6.1 正统规范的类形式 82

5.6.2 常数值 82

5.7 析构函数和终止器 84

5.8 Smalltalk语言中的元类 86

小结 87

练习 88

自学提问 88

进一步阅读材料 88

第6章 案例研究：八皇后问题 91

6.1 八皇后问题 91

6.2 使用生成器 92

6.2.1 初始化 93

6.2.2 找到解决方案 93

6.2.3 前进到下一位置 94

6.3 用几种语言实现八皇后问题 94

6.3.1 用Object Pascal语言实现八皇后问题 95

6.3.2 用C++语言实现八皇后问题 97

6.3.3 用Java语言实现八皇后问题 99

6.3.4 用Objective-C语言实现八皇后问题 102

6.3.5 用Smalltalk语言实现八皇后问题 104

6.3.6 用Ruby语言实现八皇后问题 106

小结 107

进一步阅读材料 107

自学提问 107

练习 107

第7章 案例研究：台球游戏 109

7.1 台球元素 109

7.2 图形对象 109

7.2.1 桌壁图形对象 110

7.2.2 洞口图形对象 111

7.2.3 球图形对象 112

7.3 主程序 115

7.4 使用继承 116

自学提问 118

小结 118

进一步阅读材料 118

练习 119

第8章 继承与替换 121

8.1 关于继承的直观描述 121

8.1.1 “是一个”检验 121

8.1.2 使用继承的原因 122

8.2 不同语言中的继承 123

8.3 子类、子类型和替换 124

8.4 改写和虚拟方法 125

8.5 接口和抽象类 127

8.6.1 特化子类化(子类型化) 128

8.6.2 规范子类化 128

8.6 继承的形式 128

8.6.3 构造子类化 129

8.6.4 泛化子类化 129

8.6.5 扩展子类化 130

8.6.6 限制子类化 130

8.6.7 变体子类化 130

8.6.8 结合子类化 131

8.6.9 各种继承形式小结 131

8.7 关于继承的变体 131

8.7.1 Java语言中的匿名类 131

8.7.2 继承和构造函数 132

8.7.3 虚拟析构函数 133

8.8.5 快速原型法 134

8.8.4 软件组件 134

8.8.3 接口的一致性 134

8.8.2 代码共享 134

8.8.1 软件可复用性 134

8.8 继承的优点 134

8.8.6 多态和框架 135

8.8.7 信息隐藏 135

8.9 继承的代价 135

8.9.1 程序执行速度 135

8.9.2 程序大小 135

8.9.3 消息传递的开销 136

8.9.4 程序复杂性 136

小结 136

进一步阅读材料 136

练习 137

自学提问 137

第9章 案例研究：纸牌游戏 139

9.1 PlayingCard类 139

9.2 数据类和视图类 139

9.3 游戏 141

9.4 牌堆——使用继承 142

9.4.1 缺省牌堆 144

9.4.2 花色堆 144

9.4.3 待用堆 145

9.4.4 丢弃堆 146

9.4.5 桌面堆 147

9.5 多种形式的游戏 148

9.6 图形用户界面 150

练习 153

自学提问 153

小结 153

进一步阅读材料 153

第10章 子类和子类型 155

10.1 可替换性 155

10.2 子类型 155

10.3 可替换性悖论 158

10.4 构造子类化 158

10.5 动态类型语言 160

10.6 前置条件和后置条件 161

10.7 改进语义 162

小结 162

进一步阅读材料 162

自学提问 163

练习 163

11.1 静态类型化和动态类型化 165

第11章 静态行为和动态行为 165

11.2 静态类和动态类 166

11.2.1 运行时类型决定 168

11.2.2 向下造型(反多态) 169

11.2.3 非语言支持的运行时测试 170

11.2.4 检验是否理解消息 171

11.3 静态方法绑定和动态方法绑定 171

小结 174

进一步阅读材料 174

自学提问 174

练习 174

第12章 替换的本质 177

12.1 内存布局 177

12.1.1 最小静态空间分配 178

12.1.3 动态内存分配 180

12.1.2 最大静态空间分配 180

12.2 赋值 182

12.3 复制和克隆 184

12.3.1 Smalltatk语言和Objective-C语言中的复制 184

12.3.2 C++语言中的拷贝构造函数 184

12.3.3 Java语言中的克隆 185

12.4 相同 185

12.4.1 相同和同一 186

12.4.2 相同检验的悖论 186

小结 188

进一步阅读材料 188

自学提问 188

练习 189

13.1 分类化继承 191

第13章 多重继承 191

13.2 多重继承带来的问题 193

13.2.1 名称歧义 193

13.2.2 对替换的影响 195

13.2.3 Eiffel语言中的重定义 196

13.2.4 CLOS语言的类排序解决方案 197

13.3 接口的多重继承 199

13.4 继承于公共祖先 202

13.5 内部类 205

小结 205

进一步阅读材料 206

自学提问 206

练习 206

14.1 编程语言中的多态 207

第14章 多态及软件复用 207

14.2 软件复用机制 208

14.2.1 使用组合 209

14.2.2 使用继承 211

14.2.3 组合和继承的比较 212

14.3 效率和多态 213

14.4 软件复用的普及会成为现实吗 213

小结 214

进一步阅读材料 214

自学提问 214

练习 215

第15章 重载 217

15.1 类型签名和范畴 217

15.2 基于范畴的重载 218

15.3 基于类型签名的重载 219

15.4 重定义 226

15.5 多价 227

15.6 多方法 229

小结 231

进一步阅读材料 232

自学提问 232

练习 232

第16章 改写 235

16.1 标识改写 236

16.2 代替与改进 237

16.2.1 Smalltalk语言中的代替 238

16.2.2 Beta语言中的改进 240

16.2.3 改进与子类/子类型之间的差异 242

16.2.4 CLOS语言中的封装 243

16.3 延迟方法 243

16.4 改写与遮蔽 244

16.5 协方差与反协方差 246

16.6 改写的变体 250

16.6.1 Java语言中的final方法 250

16.6.2 C#语言中的版本化 251

小结 252

进一步阅读材料 252

自学提问 252

练习 253

第17章 多态变量 255

17.1 简单多态变量 255

17.2 接收器变量 256

17.2.1 多态变量在框架中的作用 258

17.2.2 Smalltalk语言中的端点比较 259

17.2.3 self和super 260

17.3 向下造型 261

17.4 纯多态 263

小结 264

进一步阅读材料 264

自学提问 264

练习 264

第18章 泛型 267

18.1 模板函数 267

18.2 模板类 268

18.3 模板参数中的继承 270

18.4 案例研究：结合分离的类 272

小结 275

进一步阅读材料 275

自学提问 276

练习 276

第19章 容器类 277

19.1 动态类型语言中的容器 277

19.2 静态类型语言中的容器 279

19.2.1 类型化和复用之间的关系 279

19.2.2 替换和向下造型 280

19.2.3 使用替换和改写 284

19.2.4 参数化类 286

19.3 限制元素类型 287

19.4 元素遍历 289

19.4.1 迭代器循环 290

19.4.2 访问器方法 291

小结 294

进一步阅读材料 295

自学提问 295

练习 296

第20章 案例研究：标准模板库 297

20.1 迭代器 298

20.2 函数对象 299

20.3 样例程序——库存系统 301

20.4 样例程序——图表 302

20.4.1 最短路径算法 304

20.4.2 开发数据结构 305

20.5 词汇索引 308

进一步阅读材料 310

小结 310

20.6 OOP的未来 310

自学提问 311

练习 311

第21章 框架 313

21.1 复用和特化 313

21.1.1 高级抽象和低级抽象 314

21.1.2 倒置库 316

21.2 样例框架 317

21.2.1 Java Applet API 317

21.2.2 模拟框架 318

21.2.3 事件驱动的模拟框架 319

小结 324

进一步阅读材料 324

练习 325

自学提问 325

第22章 框架实例：AWT和Swing 327

22.1 AWT的类继承层次 327

22.2 布局管理器 329

22.3 监听器 331

22.4 用户界面组件 333

22.5 案例研究：颜色显示 335

22.6 Swing组件库 338

22.6.1 导入库 338

22.6.2 不同的组件 338

22.6.3 不同的绘制协议 338

练习 339

自学提问 339

进一步阅读材料 339

小结 339

22.6.4 为窗口增加组件 339

第23章 对象互连 341

23.1 耦合和内聚 341

23.1.1 耦合的种类 341

23.1.2 内聚的种类 344

23.1.3 德墨特尔法则 345

23.1.4 类级别可视性与对象级别可视性 346

23.1.5 活动值 347

23.2 子类客户和用户客户 347

23.3 存取控制和可视性 348

23.3.1 Smalltalk语言中的可视性 348

23.3.3 C++语言中的可视性 349

23.3.2 Object Pascal语言中的可视性 349

23.3.4 Java语言中的可视性 352

23.3.5 Objective-C语言中的可视性 354

23.4 有意依赖性 354

小结 355

进一步阅读材料 355

自学提问 355

练习 356

第24章 设计模式 357

24.1 控制信息流 357

24.2 描述模式 358

24.3 迭代器 359

24.4 软件工厂 360

24.5 策略 360

24.7 组合 361

24.6 单件 361

24.8 装饰器 363

24.9 双调度模式 363

24.10 享元 365

24.11 代理 365

24.12 外观 366

24.13 观察者 366

小结 367

进一步阅读材料 367

练习 368

25.1.1 类对象 368

自学提问 368

第25章 反射和内省 369

25.1 理解机制 369

25.1.2 字符串形式的类名称 370

25.1.3 检测对象类 371

25.1.4 通过类建立实例 372

25.1.5 检测对象是否理解消息 373

25.1.6 类行为 373

25.2 作为对象的方法 374

25.3 修改机制 375

25.3.1 Smalltalk语言中的方法编辑 375

25.3.2 Java语言中的动态类加载 375

25.4 元类 377

小结 378

进一步阅读材料 379

自学提问 379

第26章 分布式对象 381

26.1 地址、端口和套接字 382

26.2 一个简单的客户/服务器程序 383

26.3 多客户端 384

26.4 通过网络传输对象 389

26.5 更复杂的技术 392

小结 392

进一步阅读材料 392

自学提问 393

练习 393

第27章 实现 395

27.1 编译器和解释器 395

27.2 作为参数的接收器 395

27.3 继承方法 396

27.3.2 裁剪问题 397

27.3.1 多重继承的问题 397

27.4 改写方法 398

27.5 名称编码 400

27.6 分派表 400

27.7 字节码解释器 402

27.8 即时编译 404

小结 404

进一步阅读材料 404

自学提问 405

练习 405

附录A 八皇后问题的源代码 407

附录B 台球游戏的源代码 421

附录C 纸牌游戏的源代码 433

术语表 443

参考文献 455