研磨设计模式【2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载】

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

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

第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/DI112

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 抽象工厂模式和DAO146

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 装饰模式和AOP657

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 典型例子——JDBC721

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