# twenty-three-design-patterns
**Repository Path**: dennisdong/twenty-three-design-patterns
## Basic Information
- **Project Name**: twenty-three-design-patterns
- **Description**: 二十三种设计模式，java版本
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 1
- **Forks**: 0
- **Created**: 2023-09-24
- **Last Updated**: 2023-10-19
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# 二十三种设计模式
## 1.分类
| | 创建型 | 结构型· | 行为型 |
| ---- | ---------------------------------- | ------------------------------- | ------------------------------------------------------------ |
| 类 | Factory Method
工厂方法模式 | Adapter
适配器模式（类） | Interpreter
解释器模式
Template Method
模板方法模式 |
| | | | |
| 对象 | Abstract Factory
抽象工厂模式 | Adapter
适配器模式（对象） | Chain Of responsibility
责任链模式 |
| | Builder
生成器（建造者）模式 | Bridge
桥接模式 | Command
命令模式 |
| | Prototype
原型模式 | Composite
组合模式 | Iterator
迭代器模式 |
| | Singleton
单例模式 | Decorator
装饰模式 | Mediator
中介者模式 |
| | | Facade
外观模式 | Memento
备忘录模式 |
| | | Flyweight
享元模式 | Observer
观察者模式 |
| | | Proxy
代理模式 | State
状态模式 |
| | | | Strategy
策略模式 |
| | | | Visit
访问者模式 |
| | 5 | 7 | 11 |
## 2.意图总结
### 2.1 创建型
> 工厂方法
```java
/**
* 1.工厂方法模式（Factory Method）
*
* 意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
* Factory Method 使一个类的实例化延迟到子类
*
* 适用性：
* 1.当一个类不知道它所创建的对象的类的时候
* 2.当一个类希望由它的子类来决定创建的对象的时候
*
* 关键字：子类决定
*/
```
> 抽象工厂
```java
/**
* 抽想工厂模式（Abstract Factory）
*
* 意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
*
* 适用性：
* 1.一个系统要独立于它的产品的创建、组合和表示时
* 2.一个系统要由多个产品系列中的一个来配置
* 3.当要强调一系列相关的产品对象的设计一遍进行联合使用是
* 4.当提供一个产品类库，只想显示它们的接口而不是实现时
*
* 关键字：一系列
*
*/
```
> 生成器
```java
/**
* 生成器（建造者模式）模式（CreatedType.Builder）
*
* 意图：将一个复杂对象的构建和表示分离，使得同样的构建过程可以创建不同的表示
*
* 适用性：
* 1.当创建的复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时
* 2.当构造过程必须允许被构造的对象有所不同的表示时
*
* 关键字：复杂对象
*/
```
> 原型
```java
/**
* 原型模式（CreatedType.Prototype）
*
* 意图：指定创建对象的种类，并通过复制这些原型创建新的对象
*
* 适用性：
* 1.一个系统应该独立与他的产品创建、构成（抽象工厂模式为组合）和表示
* 2.要实例化的类是在运行时刻指定时，例如通过动态装载
* 3.为了避免创建一个与产品类层次平行的工厂类层次时
* 4.当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们，
* 可能比每次用合适的状态手动实例化该类更方便
*
* 关键字：克隆、产品层次
*/
```
> 单例
```java
/**
* 单例模式（Single）
*
* 意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点
*
* 适用性：
* 1。当类只能有一个实例，并且客户可以从一个众所周知的访问点访问它时
* 2.当这个唯一实例应该是通过子类可扩展的，并且客户无需更改代码就能使用一个扩展的实例时
*
* 关键字：唯一实例
*/
```
### 2.2 结构型
> 适配器
```java
/**
* 适配器（对象）模式（Adapter）
*
* 意图：将一个类的接口转换成客户希望的另一个接口，不兼容的两个类可以协同工作
*
* 适用性：
* 1.想使用一个已存在的类，但他的接口却不符合要求
*
* 关键字：不兼容、协同工作
*/
```
> 桥接
```java
/**
* 桥接模式（Bridge）
*
* 意图：将抽象部分与其实现分离，使他们可以独立的变化
*
* 适用性：（了解即可）
* 1.不希望在抽象和它的实现部分之间有一个固定的绑定关系。例如，这种情况可能是因
* 为，在程序运行时刻实现部分应可以被选择或者切换。
* 2.类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这是 Bridge 模式使
* 得开发者可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充。
* 3.对一个抽象的实现部分的修改应对客户不产生影响，即客户代码不必重新编译。
* 4.(C++)想对客户完全隐藏抽象的实现部分。
* 5.有许多类要生成的类层次结构。
* 6.想在多个对象间共享实现(可能使用引用计数)，但同时要求客户并不知道这一点
*
* 关键字：抽象和实现部分
*/
```
> 组合
```java
/**
* 组合模式（Composite）
*
* 意图：将对象组合的树形结构以表示“部分-整体”的层次结构。
* Composite使得用户对单个对象和组合对象的使用具有一致性
*
* 适用性：
* 1.想表示对象的部分-整体的层次结构
* 2.希望用户忽略组合对象与单个对象的不同，用户将统一的使用组合结构的所有对象
*/
```
> 装饰器
```java
/**
* 装饰器模式（Decorator）
*
* 意图：动态的给一个对象添加一些额外的职责
*
* 适用性：
* 1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
*
* 关键字：添加额外职责
*/
```
> 外观
```java
/**
* 外观模式（Facade），了解即可
*
* 意图：
* 为子系统的一组接口提供一个一致的界面
*
* 适用性：
* 1.为一个复杂子系统提供一个简单的接口时
* 2.客户端与抽象类的实现部分之间存在着很大的依赖性
* 3.当需要构建一个层次结构的子系统时，使用Facade模式定义子系统中每层的入口点
*
* 关键字：子系统
*/
```
> 享元
```java
/**
* 享元模式（FlyWeight）
*
* 意图：
* 运用共享技术有效的支持大量细粒度的对象（如五子棋和画很多圆），了解
*
* 适用性：
* 1.一个程序使用的大量的对象
* 2.完全使用大量的对象，造成很大的开销
* 3.对象的大部分状态都可变为外部状态
* 4.如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象
*
* 关键字：大量对象，共享
*/
```
> 代理
```java
/**
* 代理模式（Proxy），了解
*
* 意图：
* 为其他对象提供一种代理以控制对这个对象的访问（如代理送花）
*/
```
### 2.3 行为型
> 解释器
> 模板方法
> 责任链
```java
/**
* 责任链模式（Chain of responsibility）了解即可
*
* 意图：
* 多个对象都有机会处理请求，避免发送者和接收者的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理为止
*
* 适用性：
* 1.有多个对象处理一个请求，哪个对象处理请求运行时刻自动确定
* 2.想在不明确指定接收者的情况下，向多个对象依次提交请求
* 3.可处理一个请求对象集合应被动态指定
*/
```
> 命令
```java
/**
* 命令模式（Command）
*
* 意图：
* 将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化。对请求排队或记录请求日志，以及支持可撤销的操作
*
* 适用性：
* 1.抽象出待执行的动作以参数化某对象
* 2.在不同的时刻指定、排列和执行请求
* 3.支持撤销操作
* 4.支持修改日志
* 5.用构建在原语操作上的高层操作构建一个系统
*
* 关键字：参数化
*/
```
> 迭代器
```java
/**
* 迭代器模式（Iterator）
*
* 意图：
* 提供一种方法顺序访问一个聚合对象中的各个元素，且不需要暴露该对象的内部表示（for循环基于此模式）
*
* 适用性：
* 1.访问一个聚合对象的内容而无需暴露他的内部表示
* 2.支持对聚合对象的多种遍历
* 3.为遍历不同的聚合结构提供一个统一的接口
*
* 关键字：访问对象不暴露内部表示
*/
```
> 中介者
```java
/**
* 中介者模式（Mediator）
*
* 意图：
* 用一个对象来封装一系列的对象交互，使各对象不需要显式的引用，从而使其耦合松散，可以独立改变他们的交互
*
* 适用性：
* 1.一组对象以良好但复杂的方式进行通信，产生的依赖关系混乱且难以理解
* 2.一个对象引用其他很多对象并且与这些对象通信，导致难以复用该对象
* 3.想定制一个分布在多个类中的行为，而不产生太多的子类
*
* 关键字：通信
*/
```
> 备忘录
```java
/**
* 备忘录模式（Memento）
*
* 意图：
* 在不破坏封装性的前提下捕获一个对象的内部状态，并在对象之外保存这个状态。可以将对象恢复到原先保存的状态
*
* 适用性：
* 1.必须保存一个对象在某一时刻的状态，这样使用它时才能恢复到先前的状态
* 2.如果用一个接口来让其他对象获取这些状态，将会暴露对象的实现细节以及破坏对象的封装性时
*
* 关键字：保存状态、恢复状态
*/
```
> 观察者
```java
/**
* 观察者模式（Observer）
*
* 意图：
* 定义对象之间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都收到通知并被自动更新
*
* 适用性：
* 1.当对一个对象改变需要同事改变其他对象，而不知道有多少个对象有待改变时
* 2.当一个对象必须通知其他对象，但不能假定其他对象是谁，即不希望这些对象时紧耦合的
*
* 关键字：改变对象、通知对象
*/
```
> 状态
```java
/**
* 状态模式（State）
*
* 意图：
* 允许一个对象在其内部状态改变时改变它的行为，对象看起来是似乎改变了它的类
*
* 适用性：
* 1.一个对象的行为取决于它的状态，并且必须由运行时刻的状态改变它的行为
* 2.一个操作中有庞大的多分支条件语句， 且分支依赖于该对象的状态
*
* 关键字：状态、大量分支
*/
```
> 策略
```java
/**
* 策略模式（Strategy），商场打折
*
* 意图：
* 定义一系列的算法，将它们一个个封装起来，并使他们可以相互替换
*
* 适用性：
* 1.许多相关的类仅仅是行为有异
* 2.需要使用一个算法的不同变体
* 3.使用算法的客户不应该知道数据，避免暴露复杂的、与算法相关的结构数据
*
* 关键字：一系列算法
*/
```
> 访问者
```java
/**
* 访问者模式（Visitor）
*
* 意图：
* 一个作用域某对象结构中各元素的操作，允许不修改这些元素的类的前期下，定义作用于这些元素的新操作
*
* 适用性：
* 1.一个对象结构包含很多类对象，他们有不同的接口，而用户想对这些对象实施一些依赖于其具体类的一些操作
* 2.定义对象结构的类很少改变，但经常需要再次结构上定义新的操作
*
* 关键字：对象结构、新操作、accept
*/
```