图书介绍

研磨设计模式pdf电子书版本下载

研磨设计模式
  • 陈臣,王斌编著 著
  • 出版社: 北京:清华大学出版社
  • ISBN:9787302239239
  • 出版时间:2011
  • 标注页数:783页
  • 文件大小:164MB
  • 文件页数:801页
  • 主题词:Java语言-程序设计

PDF下载


点此进入-本书在线PDF格式电子书下载【推荐-云解压-方便快捷】直接下载PDF格式图书。移动端-PC端通用
种子下载[BT下载速度快] 温馨提示:(请使用BT下载软件FDM进行下载)软件下载地址页 直链下载[便捷但速度慢]   [在线试读本书]   [在线获取解压码]

下载说明

研磨设计模式PDF格式电子书版下载

下载的文件为RAR压缩包。需要使用解压软件进行解压得到PDF格式图书。

建议使用BT下载工具Free Download Manager进行下载,简称FDM(免费,没有广告,支持多平台)。本站资源全部打包为BT种子。所以需要使用专业的BT下载软件进行下载。如 BitComet qBittorrent uTorrent等BT下载工具。迅雷目前由于本站不是热门资源。不推荐使用!后期资源热门了。安装了迅雷也可以迅雷进行下载!

(文件页数 要大于 标注页数,上中下等多册电子书除外)

注意:本站所有压缩包均有解压码: 点击下载压缩包解压工具

图书目录

第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

精品推荐