Merge pull request #1479 from CyC2018/polish-design-patterns

Update design pattern notes
2026-10-29 15:13:44 +00:00 · 2026-10-28 03:23:35 +08:00
parent 6185fb3389 4106b6426d
commit b7570f15b0
51 changed files with 268 additions and 241 deletions
@@ -1,19 +1,16 @@
 ## 单例（Singleton）

-### Intent
-
+### 意图
 确保一个类只有一个实例，并提供该实例的全局访问点。

-### Class Diagram
-
+### 类图
 使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

 私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/eca1f422-8381-409b-ad04-98ef39ae38ba.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-singleton.png" width="760px"/> </div><br>

+### 实现
 #### Ⅰ 懒汉式-线程不安全

 以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
@@ -105,9 +102,9 @@ uniqueInstance 采用 volatile 关键字修饰也是很有必要的， `uniqueIn
 2. 初始化 uniqueInstance
 3. 将 uniqueInstance 指向分配的内存地址

-但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
+但是由于 JVM 具有重排序的特性，执行顺序有可能变成 1>3>2。重排序在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T<sub>1</sub> 执行了 1 和 3，此时 T<sub>2</sub> 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

-使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
+使用 volatile 可以禁止 JVM 的重排序，保证在多线程环境下也能正常运行。

 #### Ⅴ 静态内部类实现

@@ -175,7 +172,7 @@ public enum Singleton {
 }
 ```

-```html
+```text
 firstName
 secondName
 secondName
@@ -186,16 +183,18 @@ secondName

 该实现在多次序列化和反序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且提供 readResolve() 方法。

-### Examples
-
+### 示例
 - Logger Classes
 - Configuration Classes
 - Accessing resources in shared mode
 - Factories implemented as Singletons

-### JDK
-
+### JDK 中的应用
 - [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
 - [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
 - [java.lang.System#getSecurityManager()](https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)

+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,20 +1,15 @@
 ## 5. 中介者（Mediator）

-### Intent
-
+### 意图
 集中相关对象之间复杂的沟通和控制方式。

-### Class Diagram
-
-
-
+### 类图
 - Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
 - Colleague：同事，相关对象

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/30d6e95c-2e3c-4d32-bf4f-68128a70bc05.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-mediator.png" width="760px"/> </div><br>

+### 实现
 Alarm（闹钟）、CoffeePot（咖啡壶）、Calendar（日历）、Sprinkler（喷头）是一组相关的对象，在某个对象的事件产生时需要去操作其它对象，形成了下面这种依赖结构：

 <div align="center"> <img src="pics/mediator-before.png" width="640px"/> </div><br>
@@ -154,17 +149,21 @@ public class Client {
 }
 ```

-```java
+```text
 doAlarm()
 doCoffeePot()
 doCalender()
 doSprinkler()
 ```

-### JDK
-
+### JDK 中的应用
 - All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
 - [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
 - submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
 - scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
 - [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,21 +1,16 @@
 ## 享元（Flyweight）

-### Intent
-
-
-
+### 意图
 利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。

-### Class Diagram
-
+### 类图
 - Flyweight：享元对象
 - IntrinsicState：内部状态，享元对象共享内部状态
 - ExtrinsicState：外部状态，每个享元对象的外部状态不同

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/5f5c22d5-9c0e-49e1-b5b0-6cc7032724d4.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-flyweight.png" width="760px"/> </div><br>

+### 实现
 ```java
 public interface Flyweight {
    void doOperation(String extrinsicState);
@@ -68,7 +63,7 @@ public class Client {
 }
 ```

-```html
+```text
 Object address: 1163157884
 IntrinsicState: aa
 ExtrinsicState: x
@@ -77,11 +72,15 @@ IntrinsicState: aa
 ExtrinsicState: y
 ```

-### JDK
-
+### JDK 中的应用
 Java 利用缓存来加速大量小对象的访问时间。

 - java.lang.Integer#valueOf(int)
 - java.lang.Boolean#valueOf(boolean)
 - java.lang.Byte#valueOf(byte)
 - java.lang.Character#valueOf(char)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,11 +1,9 @@
 ## 代理（Proxy）

-### Intent
-
+### 意图
 控制对其它对象的访问。

-### Class Diagram
-
+### 类图
 代理有以下四类：

 - 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
@@ -13,10 +11,9 @@
 - 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
 - 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/9b679ff5-94c6-48a7-b9b7-2ea868e828ed.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-proxy.png" width="760px"/> </div><br>

+### 实现
 以下是一个虚拟代理的实现，模拟了图片延迟加载的情况下使用与图片大小相等的临时内容去替换原始图片，直到图片加载完成才将图片显示出来。

 ```java
@@ -98,7 +95,11 @@ public class ImageViewer {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - java.lang.reflect.Proxy
 - RMI
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,15 +1,12 @@
 ## 6. 原型模式（Prototype）

-### Intent
-
+### 意图
 使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。

-### Class Diagram
-
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/b8922f8c-95e6-4187-be85-572a509afb71.png"/> </div><br>
-
-### Implementation
+### 类图
+<div align="center"> <img src="pics/dp-prototype.png" width="760px"/> </div><br>

+### 实现
 ```java
 public abstract class Prototype {
    abstract Prototype myClone();
@@ -47,10 +44,14 @@ public class Client {
 }
 ```

-```html
+```text
 abc
 ```

-### JDK
-
+### JDK 中的应用
 - [java.lang.Object#clone()](http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,7 +1,6 @@
 ## 2. 命令（Command）

-### Intent
-
+### 意图
 将命令封装成对象中，具有以下作用：

 - 使用命令来参数化其它对象
@@ -9,17 +8,15 @@
 - 将命令的操作记录到日志中
 - 支持可撤销的操作

-### Class Diagram
-
+### 类图
 - Command：命令
 - Receiver：命令接收者，也就是命令真正的执行者
 - Invoker：通过它来调用命令
 - Client：可以设置命令与命令的接收者

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c44a0342-f405-4f17-b750-e27cf4aadde2.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-command.png" width="760px"/> </div><br>

+### 实现
 设计一个遥控器，可以控制电灯开关。

 <div align="center"> <img src="pics/command-remote.png" width="740px"/> </div><br>
@@ -120,8 +117,12 @@ public class Client {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)
 - [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki)
 - [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,19 +1,16 @@
 ## 备忘录（Memento）

-### Intent
-
+### 意图
 在不违反封装的情况下获得对象的内部状态，从而在需要时可以将对象恢复到最初状态。

-### Class Diagram
-
+### 类图
 - Originator：原始对象
 - Caretaker：负责保存好备忘录
 - Memento：备忘录，存储原始对象的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/50678f34-694f-45a4-91c6-34d985c83fee.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-memento.png" width="760px"/> </div><br>

+### 实现
 以下实现了一个简单计算器程序，可以输入两个值，然后计算这两个值的和。备忘录模式允许将这两个值存储起来，然后在某个时刻用存储的状态进行恢复。

 实现参考：[Memento Pattern - Calculator Example - Java Sourcecode](https://www.oodesign.com/memento-pattern-calculator-example-java-sourcecode.html)
@@ -165,12 +162,16 @@ public class Client {
 }
 ```

-```html
+```text
 110
 -273
 110
 ```

-### JDK
-
+### JDK 中的应用
 - java.io.Serializable
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,17 +1,16 @@
 ## 外观（Facade）

-### Intent
-
+### 意图
 提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。

-### Class Diagram
+### 类图
+<div align="center"> <img src="pics/dp-facade.png" width="760px"/> </div><br>
+
+### 实现
+观看电影需要操作很多电器，使用外观模式实现一键看电影功能。

 <div align="center"> <img src="pics/facade-movie.png" width="740px"/> </div><br>

-### Implementation
-
-观看电影需要操作很多电器，使用外观模式实现一键看电影功能。
-
 ```java
 public class SubSystem {
    public void turnOnTV() {
@@ -52,3 +51,8 @@ public class Client {
 ### 设计原则

 最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,19 +1,16 @@
 ## 工厂方法（Factory Method）

-### Intent
-
+### 意图
 定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。

-### Class Diagram
-
+### 类图
 在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。

 下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/f4d0afd0-8e78-4914-9e60-4366eaf065b5.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-factory-method.png" width="760px"/> </div><br>

+### 实现
 ```java
 public abstract class Factory {
    abstract public Product factoryMethod();
@@ -48,8 +45,7 @@ public class ConcreteFactory2 extends Factory {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--)
 - [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-)
 - [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--)
@@ -57,3 +53,8 @@ public class ConcreteFactory2 extends Factory {
 - [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-)
 - [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-)
 - [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,11 +1,9 @@
 ## 4. 抽象工厂（Abstract Factory）

-### Intent
-
+### 意图
 提供一个接口，用于创建   **相关的对象家族**  。

-### Class Diagram
-
+### 类图
 抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

 抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。
@@ -14,10 +12,9 @@

 从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/e2190c36-8b27-4690-bde5-9911020a1294.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-abstract-factory.png" width="760px"/> </div><br>

+### 实现
 ```java
 public class AbstractProductA {
 }
@@ -90,8 +87,12 @@ public class Client {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
 - [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
 - [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -2,19 +2,16 @@

 ## 桥接（Bridge）

-### Intent
-
+### 意图
 将抽象与实现分离开来，使它们可以独立变化。

-### Class Diagram
-
+### 类图
 - Abstraction：定义抽象类的接口
 - Implementor：定义实现类接口

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2a1f8b0f-1dd7-4409-b177-a381c58066ad.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-bridge.png" width="760px"/> </div><br>

+### 实现
 RemoteControl 表示遥控器，指代 Abstraction。

 TV 表示电视，指代 Implementor。
@@ -152,7 +149,11 @@ public class Client {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
 - JDBC
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,17 +1,14 @@
 ## 模板方法（Template Method）

-### Intent
-
+### 意图
 定义算法框架，并将一些步骤的实现延迟到子类。

 通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。

-### Class Diagram
-
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ac6a794b-68c0-486c-902f-8d988eee5766.png"/> </div><br>
-
-### Implementation
+### 类图
+<div align="center"> <img src="pics/dp-template.png" width="760px"/> </div><br>

+### 实现
 冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。

 <div align="center"> <img src="pics/template-recipe.png" width="740px"/> </div><br>
@@ -80,7 +77,7 @@ public class Client {
 }
 ```

-```html
+```text
 boilWater
 Coffee.brew
 pourInCup
@@ -92,9 +89,13 @@ pourInCup
 Tea.addCondiments
 ```

-### JDK
-
+### JDK 中的应用
 - java.util.Collections#sort()
 - java.io.InputStream#skip()
 - java.io.InputStream#read()
 - java.util.AbstractList#indexOf()
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,15 +1,12 @@
 ## 8. 状态（State）

-### Intent
-
+### 意图
 允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。

-### Class Diagram
-
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/79df886f-fdc3-4020-a07f-c991bb58e0d8.png"/> </div><br>
-
-### Implementation
+### 类图
+<div align="center"> <img src="pics/dp-state.png" width="760px"/> </div><br>

+### 实现
 糖果销售机有多种状态，每种状态下销售机有不同的行为，状态可以发生转移，使得销售机的行为也发生改变。

 <div align="center"> <img src="pics/state-gumball.png" width="740px"/> </div><br>
@@ -272,7 +269,7 @@ public class Client {
 }
 ```

-```html
+```text
 You insert a quarter
 You turned...
 A gumball comes rolling out the slot...
@@ -299,3 +296,8 @@ You can't insert a quarter, the machine is sold out
 You turned, but there are no gumballs
 No gumball dispensed
 ```
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,15 +1,12 @@
 ## 5. 生成器（Builder）

-### Intent
-
+### 意图
 封装一个对象的构造过程，并允许按步骤构造。

-### Class Diagram
-
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/db5e376d-0b3e-490e-a43a-3231914b6668.png"/> </div><br>
-
-### Implementation
+### 类图
+<div align="center"> <img src="pics/dp-builder.png" width="760px"/> </div><br>

+### 实现
 以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。

 ```java
@@ -76,14 +73,18 @@ public class Client {
 }
 ```

-```html
+```text
 abcdefghijklmnopqrstuvwxyz
 ```

-### JDK
-
+### JDK 中的应用
 - [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)
 - [java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-)
 - [java.lang.StringBuffer](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-)
 - [java.lang.Appendable](http://docs.oracle.com/javase/8/docs/api/java/lang/Appendable.html)
 - [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,17 +1,14 @@
 ## 空对象（Null）

-### Intent
-
+### 意图
 使用什么都不做的空对象来代替 NULL。

 一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。

-### Class Diagram
-
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/22870bbe-898f-4c17-a31a-d7c5ee5d1c10.png"/> </div><br>
-
-### Implementation
+### 类图
+<div align="center"> <img src="pics/dp-null-object.png" width="760px"/> </div><br>

+### 实现
 ```java
 public abstract class AbstractOperation {
    abstract void request();
@@ -51,3 +48,8 @@ public class Client {
    }
 }
 ```
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,17 +1,17 @@
 ## 9. 策略（Strategy）

-### Intent
-
+### 意图
 定义一系列算法，封装每个算法，并使它们可以互换。

 策略模式可以让算法独立于使用它的客户端。

-### Class Diagram
-
+### 类图
 - Strategy 接口定义了一个算法族，它们都实现了  behavior() 方法。
 - Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/cd1be8c2-755a-4a66-ad92-2e30f8f47922.png"/> </div><br>
+下图按后文的鸭子示例画出：Duck 是 Context，QuackBehavior 是 Strategy，quack()、performQuack() 和 setQuackBehavior() 分别对应 behavior()、doSomething() 和 setStrategy()。
+
+<div align="center"> <img src="pics/dp-strategy.png" width="760px"/> </div><br>

 ### 与状态模式的比较

@@ -19,8 +19,7 @@

 状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。

-### Implementation
-
+### 实现
 设计一个鸭子，它可以动态地改变叫声。这里的算法族是鸭子的叫声行为。

 ```java
@@ -77,13 +76,17 @@ public class Client {
 }
 ```

-```html
+```text
 squeak!
 quack!
 ```

-### JDK
-
+### JDK 中的应用
 - java.util.Comparator#compare()
 - javax.servlet.http.HttpServlet
 - javax.servlet.Filter#doFilter()
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,19 +1,16 @@
 ## 简单工厂（Simple Factory）

-### Intent
-
+### 意图
 在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。

-### Class Diagram
-
+### 类图
 简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

 这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/40c0c17e-bba6-4493-9857-147c0044a018.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-simple-factory.png" width="760px"/> </div><br>

+### 实现
 ```java
 public interface Product {
 }
@@ -80,3 +77,8 @@ public class Client {
    }
 }
 ```
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,19 +1,16 @@
 ## 组合（Composite）

-### Intent
-
+### 意图
 将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。

-### Class Diagram
-
+### 类图
 组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。

 组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2b8bfd57-b4d1-4a75-bfb0-bcf1fba4014a.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-composite.png" width="760px"/> </div><br>

+### 实现
 ```java
 public abstract class Component {
    protected String name;
@@ -114,7 +111,7 @@ public class Client {
 }
 ```

-```html
+```text
 Composite:root
 --left:1
 --Composite:2
@@ -124,10 +121,14 @@ Composite:root
 --left:3
 ```

-### JDK
-
+### JDK 中的应用
 - javax.swing.JComponent#add(Component)
 - java.awt.Container#add(Component)
 - java.util.Map#putAll(Map)
 - java.util.List#addAll(Collection)
 - java.util.Set#addAll(Collection)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,17 +1,14 @@
 ## 装饰（Decorator）

-### Intent
-
+### 意图
 为对象动态添加功能。

-### Class Diagram
-
+### 类图
 装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/6b833bc2-517a-4270-8a5e-0a5f6df8cd96.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-decorator.png" width="760px"/> </div><br>

+### 实现
 设计不同种类的饮料，饮料可以添加配料，比如可以添加牛奶，并且支持动态添加新配料。每增加一种配料，该饮料的价格就会增加，要求计算一种饮料的价格。

 下图对应后面的代码：HouseBlend 饮料先被 Mocha 包裹，Mocha 又被 Milk 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
@@ -88,7 +85,7 @@ public class Client {
 }
 ```

-```html
+```text
 3.0
 ```

@@ -98,10 +95,14 @@ public class Client {

 不可能把所有的类设计成都满足这一原则，应当把该原则应用于最有可能发生改变的地方。

-### JDK
-
+### JDK 中的应用
 - java.io.BufferedInputStream(InputStream)
 - java.io.DataInputStream(InputStream)
 - java.io.BufferedOutputStream(OutputStream)
 - java.util.zip.ZipOutputStream(OutputStream)
 - java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,23 +1,20 @@
 ## 7. 观察者（Observer）

-### Intent
-
+### 意图
 定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且自动更新状态。

 主题（Subject）是被观察的对象，而其所有依赖者（Observer）称为观察者。

 <div align="center"> <img src="pics/observer-intent.png" width="740px"/> </div><br>

-### Class Diagram
-
+### 类图
 主题（Subject）具有注册和移除观察者、并通知所有观察者的功能，主题是通过维护一张观察者列表来实现这些操作的。

 观察者（Observer）的注册功能需要调用主题的 registerObserver() 方法。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/a8c8f894-a712-447c-9906-5caef6a016e3.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-observer.png" width="760px"/> </div><br>

+### 实现
 天气数据布告板会在天气信息发生改变时更新其内容，布告板有多个，并且在将来会继续增加。

 <div align="center"> <img src="pics/observer-run.png" width="740px"/> </div><br>
@@ -119,16 +116,20 @@ public class WeatherStation {
 }
 ```

-```html
+```text
 CurrentConditionsDisplay.update: 0.0 0.0 0.0
 StatisticsDisplay.update: 0.0 0.0 0.0
 CurrentConditionsDisplay.update: 1.0 1.0 1.0
 StatisticsDisplay.update: 1.0 1.0 1.0
 ```

-### JDK
-
+### JDK 中的应用
 - [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
 - [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
 - [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
 - [RxJava](https://github.com/ReactiveX/RxJava)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,18 +1,15 @@
 ## 解释器（Interpreter）

-### Intent
-
+### 意图
 为语言创建解释器，通常由语言的语法和语法分析来定义。

-### Class Diagram
-
+### 类图
 - TerminalExpression：终结符表达式，每个终结符都需要一个 TerminalExpression。
 - Context：上下文，包含解释器之外的一些全局信息。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/2b125bcd-1b36-43be-9b78-d90b076be549.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-interpreter.png" width="760px"/> </div><br>

+### 实现
 以下是一个规则检验器实现，具有 and 和 or 规则，通过规则可以构建一棵解析树，用来检验一个文本是否满足解析树定义的规则。

 例如一棵解析树为 D And (A Or (B C))，文本 "D A" 满足该解析树定义的规则。
@@ -110,14 +107,18 @@ public class Client {
 }
 ```

-```html
+```text
 true
 false
 ```

-### JDK
-
+### JDK 中的应用
 - [java.util.Pattern](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
 - [java.text.Normalizer](http://docs.oracle.com/javase/8/docs/api/java/text/Normalizer.html)
 - All subclasses of [java.text.Format](http://docs.oracle.com/javase/8/docs/api/java/text/Format.html)
 - [javax.el.ELResolver](http://docs.oracle.com/javaee/7/api/javax/el/ELResolver.html)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,19 +1,16 @@
 ## 访问者（Visitor）

-### Intent
-
+### 意图
 为一个对象结构（比如组合结构）增加新能力。

-### Class Diagram
-
+### 类图
 - Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
 - ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
 - ObjectStructure：对象结构，可以是组合结构，或者是一个集合。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/79c6f036-bde6-4393-85a3-ef36a0327bd2.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-visitor.png" width="780px"/> </div><br>

+### 实现
 ```java
 public interface Element {
    void accept(Visitor visitor);
@@ -182,7 +179,7 @@ public class Client {
 }
 ```

-```html
+```text
 customer1
 order1
 item1
@@ -200,7 +197,11 @@ Number of orders:    4
 Number of items:     6
 ```

-### JDK
-
+### JDK 中的应用
 - javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
 - javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,17 +1,14 @@
 ## 责任链（Chain Of Responsibility）

-### Intent
-
+### 意图
 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。

-### Class Diagram
-
+### 类图
 - Handler：定义处理请求的接口，并且实现后继链（successor）

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/ca9f23bf-55a4-47b2-9534-a28e35397988.png"/> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-chain.png" width="760px"/> </div><br>

+### 实现
 ```java
 public abstract class Handler {

@@ -117,13 +114,17 @@ public class Client {
 }
 ```

-```html
+```text
 request1 is handle by ConcreteHandler1
 request2 is handle by ConcreteHandler2
 ```

-### JDK
-
+### JDK 中的应用
 - [java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29)
 - [Apache Commons Chain](https://commons.apache.org/dormant/commons-chain/)
 - [javax.servlet.Filter#doFilter()](http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,19 +1,16 @@
 ## 迭代器（Iterator）

-### Intent
-
+### 意图
 提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。

-### Class Diagram
-
+### 类图
 - Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
 - Iterator 主要定义了 hasNext() 和 next() 方法；
 - Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。

-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/image-20201102012333804.png" alt="image-20191130164425351" style="zoom: 67%;" /> </div><br>
-
-### Implementation
+<div align="center"> <img src="pics/dp-iterator.png" width="760px"/> </div><br>

+### 实现
 ```java
 public interface Aggregate {
    Iterator createIterator();
@@ -83,7 +80,11 @@ public class Client {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
 - [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
@@ -1,20 +1,17 @@
 ## 1. 适配器（Adapter）

-### Intent
-
+### 意图
 把一个类接口转换成另一个用户需要的接口。

 <div align="center"> <img src="pics/adapter-turkey.png" width="740px"/> </div><br>

-### Class Diagram
-
-<div align="center"> <img src="pics/adapter-class-diagram.png"/> </div><br>
-
-### Implementation
+### 类图
+<div align="center"> <img src="pics/dp-adapter.png" width="760px"/> </div><br>

+### 实现
 鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。

-要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
+要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子。

 ```java
 public interface Duck {
@@ -62,9 +59,13 @@ public class Client {
 }
 ```

-### JDK
-
+### JDK 中的应用
 - [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
 - [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
 - [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
 - [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
+
+## 参考资料
+
+- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.