研磨设计模式

Posted 2021-01-01 revoid

第1章 设计模式基础

　　1.1 设计模式是什么

　　　　1.1.1 什么是模式

　　　　1.1.2 设计模式的概念

　　　　1.1.3 设计模式的理解

　　　　1.1.4 设计模式的历史

　　1.2 设计模式有什么

　　　　1.2.1 设计模式的组成

　　　　1.2.2 设计模式的分类

　　1.3 设计模式的学习

　　　　1.3.1 为什么要学习设计模式

　　　　1.3.2 学习设计模式的层次

　　　　1.3.3 如何学习设计模式

　　1.4 本书的组织方式

　　　　1.4.1 本书所讲述的设计模式的提纲

　　　　1.4.2 每个模式的讲述结构

第2章 简单工厂

　　2.1 场景问题

　　　　2.1.1 接口回顾

　　　　2.1.2 面向接口编程

　　　　2.1.3 不用模式的解决方案

　　　　2.1.4 有何问题

　　2.2 场景问题

　　　　2.2.1 使用简单工厂来解决问题

　　　　2.2.2 简单工厂的结构和说明

　　　　2.2.3 简单工厂示例代码

　　　　2.2.4 使用简单工厂重写示例

　　2.3 模式讲解

　　　　2.3.1 典型疑问

　　　　2.3.2 认识简单工厂

　　　　2.3.3 简单工厂中方法的写法

　　　　2.3.4 可配置的简单工厂

　　　　2.3.5 简单工厂的优缺点

　　　　2.3.6 思考简单工厂

　　　　2.3.7 相关模式

第3章 外观模式(Facade)

　　3.1 场景问题

　　　　3.1.1 生活中的示例

　　　　3.1.2 代码生成的应用

　　　　3.1.3 不用模式的解决方案

　　　　3.1.4 有何问题

　　3.2 解决方案

　　　　3.2.1 使用外观模式来解决问题

　　　　3.2.2 外观模式的结构和说明

　　　　3.2.3 外观模式示例代码

　　　　3.2.4 使用外观模式重写示例

　　3.3 模式讲解

　　　　3.3.1 认识外观模式

　　　　3.3.2 外观模式的实现

　　　　3.3.3 外观模式的优缺点

　　　　3.3.4 思考外观模式

　　　　3.3.5 相关模式

第4章 适配器模式(Adapter)

　　4.1 场景问题

　　　　4.1.1 装配电脑的例子

　　　　4.1.2 同时支持数据库和文件的日志管理

　　　　4.1.3 有何问题

　　4.2 解决方案

　　　　4.2.1 使适配器模式来解决问题

　　　　4.2.2 适配器模式的结构和说明

　　　　4.2.3 适配器模式示例代码

　　　　4.2.4 使用适配器模式来实现示例

　　4.3 模式讲解

　　　　4.3.1 认识适配器模式

　　　　4.3.2 适配器模式的实现

　　　　4.3.3 双向适配器

　　　　4.3.4 对象适配器和类适配器

　　　　4.3.5 适配器模式的优缺点

　　　　4.3.6 思考适配器模式

　　　　4.3.7 相关模式

第5章 单例模式(Singleton)

　　5.1 场景问题

　　　　5.1.1 读取配置文件的内容

　　　　5.1.2 不用模式的解决方案

　　　　5.1.3 有何问题

　　5.2 解决方案

　　　　5.2.1 使用单例模式来解决问题

　　　　5.2.2 单例模式的结构和说明

　　　　5.2.3 单例模式示例代码

　　　　5.2.4 使用单例模式重写示例

　　5.3 模式讲解

　　　　5.3.1 认识单例模式

　　　　5.3.2 懒汉式和饿汉式实现

　　　　5.3.3 延迟加载的思想

　　　　5.3.4 缓存的思想

　　　　5.3.5 Java中缓存的基本实现

　　　　5.3.6 利用缓存来实现单例模式

　　　　5.3.7 单例模式的优缺点

　　　　5.3.8 在Java中一种更好的单例实现方式

　　　　5.3.9 单例和枚举

　　　　5.3.10 思考单例模式

　　　　5.3.11 相关模式

第6章 工厂方法模式(Factory Method)

　　6.1 场景问题

　　　　6.1.1 导出数据的应用框架

　　　　6.1.2 框架的基础知识

　　　　6.1.3 有何问题

　　6.2 解决方案

　　　　6.2.1 使用工厂方法模式来解决问题

　　　　6.2.2 工厂方法模式的结构和说明

　　　　6.2.3 工厂方法模式示例代码

　　　　6.2.4 使用工厂方法模式来实现示例

　　6.3 模式讲解

　　　　6.3.1 认识工厂方法模式

　　　　6.3.2 工厂方法模式与IoC/DI

　　　　6.3.3 平行的类层次结构

　　　　6.3.4 参数化工厂方法

　　　　6.3.5 工厂方法模式的优缺点

　　　　6.3.6 思考工厂方法模式

　　　　6.3.7 相关模式

第7章 抽象工厂模式(Abstract Factory)

　　7.1 场景问题

　　　　7.1.1 选择组装电脑的配件

　　　　7.1.2 不用模式的解决方案

　　　　7.1.3 有何问题

　　7.2 解决方案

　　　　7.2.1 使用抽象工厂模式来解决问题

　　　　7.2.2 抽象工厂模式的结构和说明

　　　　7.2.3 抽象工厂模式示例代码

　　　　7.2.4 使用抽象工厂模式重写示例

　　7.3 模式讲解

　　　　7.3.1 认识抽象工厂模式

　　　　7.3.2 定义可扩展的工厂

　　　　7.3.3 抽象工厂模式和DAO

　　　　7.3.4 抽象工厂模式的优缺点

　　　　7.3.5 思考抽象工厂模式

　　　　7.3.6 相关模式

第8章 生成器模式(Builder)

　　8.1 场景问题

　　　　8.1.1 继续导出数据的应用框架

　　　　8.1.2 不用模式的解决方案

　　　　8.1.3 有何问题

　　8.2 解决方案

　　　　8.2.1 使用生成器模式来解决问题

　　　　8.2.2 生成器模式的结构和说明

　　　　8.2.3 生成器模式示例代码

　　　　8.2.4 使用生成器模式重写示例

　　8.3 模式讲解

　　　　8.3.1 认识生成器模式

　　　　8.3.2 生成器模式的实现

　　　　8.3.3 使用生成器模式构建复杂对象

　　　　8.3.4 生成器模式的优点

　　　　8.3.5 思考生成器模式

　　　　8.3.6 相关模式

第9章 原型模式(Prototype)

　　9.1 场景问题

　　　　9.1.1 订单处理系统

　　　　9.1.2 不用模式的解决方案

　　　　9.1.3 有何问题

　　9.2 解决方案

　　　　9.2.1 使用原型模式来解决问题

　　　　9.2.2 原型模式的结构和说明

　　　　9.2.3 原型模式示例代码

　　　　9.2.4 使用原型模式重写示例

　　9.3 模式讲解

　　　　9.3.1 认识原型模式

　　　　9.3.2 Java中的克隆方法

　　　　9.3.3 浅度克隆和深度克隆

　　　　9.3.4 原型管理器

　　　　9.3.5 原型模式的优缺点

　　　　9.3.6 思考原型模式

　　　　9.3.7 相关模式

第10章 中介者模式(Mediator)

　　10.1 场景问题

　　　　10.1.1 如果没有主板

　　　　10.1.2 有何问题

　　　　10.1.3 使用电脑来看电影

　　10.2 解决方案

　　　　10.2.1 使用中介者模式来解决问题

　　　　10.2.2 中介者模式的结构和说明

　　　　10.2.3 中介者模式示例代码

　　　　10.2.4 使用中介者模式来实现示例

　　10.3 模式讲解

　　　　10.3.1 认识中介者模式

　　　　10.3.2 广义中介者

　　　　10.3.3 中介者模式的优缺点

　　　　10.3.4 思考中介者模式

　　　　10.3.5 相关模式

第11章 代理模式(Proxy)

　　11.1 场景问题

　　　　11.1.1 访问多条数据

　　　　11.1.2 不用模式的解决方案

　　　　11.1.3 有何问题

　　11.2 解决方案

　　　　11.2.1 使用代理模式来解决问题

　　　　11.2.2 代理模式的结构和说明

　　　　11.2.3 代理模式示例代码

　　　　11.2.4 使用代理模式重写示例

　　11.3 模式讲解

　　　　11.3.1 认识代理模式

　　　　11.3.2 保护代理

　　　　11.3.3 Java中的代理

　　　　11.3.4 代理模式的特点

　　　　11.3.5 思考代理模式

　　　　11.3.6 相关模式

第12章 观察者模式(Observer)

　　12.1 场景问题

　　　　12.1.1 订阅报纸的过程

　　　　12.1.2 订阅报纸的问题

　　12.2 解决方案

　　　　12.2.1 使用观察者模式来解决问题

　　　　12.2.2 观察者模式的结构和说明

　　　　12.2.3 观察者模式示例代码

　　　　12.2.4 使用观察者模式实现示例

　　12.3 模式讲解

　　　　12.3.1 认识观察者模式

　　　　12.3.2 推模式和拉模型

　　　　12.3.3 Java中的观察者模式

　　　　12.3.4 观察者模式的优缺点

　　　　12.3.5 思考观察者模式

　　　　12.3.6 Swing中的观察者

　　　　12.3.7 简单变形示例-区别对待观察者

　　　　12.3.8 相关模式

第13章 命令模式(Command)

　　13.1 场景问题

　　　　13.1.1 如何开机

　　　　13.1.2 与我何干

　　　　13.1.3 有何问题

　　13.2 解决方案

　　　　13.2.1 使用命令模式来解决问题

　　　　13.2.2 命令模式的结构和说明

　　　　13.2.3 命令模式示例代码

　　　　13.2.4 使用命令模式l来实现示例

　　13.3 模式讲解

　　　　13.3.1 认识命令模式

　　　　13.3.2 参数化配置

　　　　13.3.3 可撤销的操作

　　　　13.3.4 宏命令

　　　　13.3.5 队列请求

　　　　13.3.6 日志请求

　　　　13.3.7 命令模式的优点

　　　　13.3.8 思考命令模式

　　　　13.3.9 退化的命令模式

　　　　13.3.10 相关模式

第14章 迭代器模式(Iterator)

　　14.1 场景问题

　　　　14.1.1 工资表数据的集合

　　　　14.1.2 有何问题

　　14.2 解决方案

　　　　14.2.1 使用迭代器模式解决问题

　　　　14.2.2 迭代器模式的结构和说明

　　　　14.2.3 迭代器模式示例代码

　　　　14.2.4 使用迭代器模式来实现示例

　　14.3 模式讲解

　　　　14.3.1 认识迭代器模式

　　　　14.3.2 使用Java的迭代器

　　　　14.3.3 带迭代策略的迭代器

　　　　14.3.4 双向迭代器

　　　　14.3.5 迭代器模式的有点

　　　　14.3.6 思考迭代器模式

　　　　14.3.7 翻页迭代

　　　　14.3.8 相关模式

第15章 组合模式(Composite)

　　15.1 场景问题

　　　　15.1.1 商品类别树

　　　　15.1.2 不用模式的解决方案

　　　　15.1.3 有何问题

　　15.2 解决方案

　　　　15.2.1 使用组合模式来解决问题

　　　　15.2.2 组合模式的结构和说明

　　　　15.2.3 组合模式示例代码

　　　　15.2.4 使用组合模式重写示例

　　15.3 模式讲解

　　　　15.3.1 认识组合模式

　　　　15.3.2 安全性和透明性

　　　　15.3.3 父组件引用

　　　　15.3.4 环状引用

　　　　15.3.5 组合模式的优缺点

　　　　15.3.6 思考组合模式

　　　　15.3.7 相关模式

第16章 模板方法模式(Template Method)

　　16.1 场景问题

　　　　16.1.1 登录控制

　　　　16.1.2 不用模式的解决方案

　　　　16.1.3 有何问题

　　16.2. 解决方案

　　　　16.2.1 使用模板方法模式来解决问题

　　　　16.2.2 模板方法模式的结构和说明

　　　　16.2.3 模板方法模式示例代码

　　　　16.2.4 使用模板方法模式重写示例

　　16.3 模式讲解

　　　　16.3.1 认识模板方法模式

　　　　16.3.2 模板的写法

　　　　16.3.3 Java回调与模板方法模式

　　　　16.3.4 典型应用:排序

　　　　16.3.5 实现通用的增删改查

　　　　16.3.6 模板方法模式的优缺点

　　　　16.3.7 思考模板方法模式

　　　　16.3.8 相关模式

第17章 策略模式(Strategy)

　　17.1 场景问题

　　　　17.1.1 报价管理

　　　　17.1.2 不用模式的解决方案

　　　　17.1.3 有何问题

　　17.2 解决方案

　　　　17.2.1 使用策略模式来解决问题

　　　　17.2.2 策略模式的结构和说明

　　　　17.2.3 策略模式示例代码

　　　　17.2.4 使用策略模式重写示例

　　17.3 模式讲解

　　　　17.3.1 认识策略模式

　　　　17.3.2 Context和Strategy的关系

　　　　17.3.3