* [一、概述](#一概述) * [二、创建型](#二创建型) * [1. 单例模式](#1-单例模式) * [2. 简单工厂](#2-简单工厂) * [3. 工厂方法模式](#3-工厂方法模式) * [4. 抽象工厂模式](#4-抽象工厂模式) * [5. 生成器](#5-生成器) * [6. 原型模式](#6-原型模式) * [三、行为型](#三行为型) * [1. 责任链](#1-责任链) * [2. 命令模式](#2-命令模式) * [3. 解释器模式](#3-解释器模式) * [4. 迭代器](#4-迭代器) * [5. 中间人模式](#5-中间人模式) * [6. 备忘录模式](#6-备忘录模式) * [7. 观察者模式](#7-观察者模式) * [8. 策略模式](#8-策略模式) * [9. 模板方法](#9-模板方法) * [10. 访问者模式](#10-访问者模式) * [11. 空对象模式](#11-空对象模式) * [四、结构型](#四结构型) * [1. 适配器模式](#1-适配器模式) * [2. 桥接模式](#2-桥接模式) * [3. 组合模式](#3-组合模式) * [4. 装饰者模式](#4-装饰者模式) * [5. 蝇量模式](#5-蝇量模式) * [6. 动态代理](#6-动态代理) * [参考资料](#参考资料) # 一、概述设计模式不是代码，而是解决问题的方案，学习现有的设计模式可以做到经验复用。拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。 # 二、创建型 ## 1. 单例模式 ### 意图确保一个类只有一个实例，并提供该实例的全局访问点。 ### 类图使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

### 实现 #### 懒汉式-线程不安全以下实现中，私有静态变量 uniqueInstance 被延迟化实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么多个线程会执行 uniqueInstance = new Singleton(); 语句，这将导致实例化多次 uniqueInstance。 ```java public class Singleton { private static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } return uniqueInstance; } } ``` #### 懒汉式-线程安全只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了对 uniqueInstance 进行多次实例化的问题。但是这样有一个问题，就是当一个线程进入该方法之后，其它线程试图进入该方法都必须等待，因此性能上有一定的损耗。 ```java public static synchronized Singleton getUniqueInstance() { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } return uniqueInstance; } ``` #### 饿汉式-线程安全线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。但是直接实例化的方式也丢失了延迟实例化带来的节约资源的优势。 ```java private static Singleton uniqueInstance = new Singleton(); ``` #### 双重校验锁-线程安全 uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行。也就是说，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。 ```java public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { if (uniqueInstance == null) { synchronized (Singleton.class) { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } } } return uniqueInstance; } } ``` 考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句，只是先后的问题，也就是说会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 判断。 ```java if (uniqueInstance == null) { synchronized (Singleton.class) { uniqueInstance = new Singleton(); } } ``` uniqueInstance 采用 volatile 关键字修饰也是很有必要的。uniqueInstance = new Singleton(); 这段代码其实是分为三步执行。 1. 分配内存空间。 2. 初始化对象。 3. 将 uniqueInstance 指向分配的内存地址。但是由于 JVM 具有指令重排的特性，有可能执行顺序变为了 1>3>2，这在单线程情况下自然是没有问题。但如果是多线程下，有可能获得是一个还没有被初始化的实例，以致于程序出错。使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。 #### 枚举实现这是单例模式的最佳实践，它实现简单，并且在复杂的序列化或者反射攻击的时候，能够防止实例化多次。 ```java public enum Singleton { uniqueInstance; } ``` 考虑以下单例模式的实现，该 Singleton 在每次序列化的时候都会创建一个新的实例，为了保证只创建一个实例，必须声明所有字段都是 transient，并且提供一个 readResolve() 方法。 ```java public class Singleton implements Serializable{ private static Singleton uniqueInstance; private Singleton() { } public static synchronized Singleton getUniqueInstance() { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } return uniqueInstance; } } ``` 如果不使用枚举来实现单例模式，会出现反射攻击，因为通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象。如果要防止这种攻击，需要在构造函数中添加防止实例化第二个对象的代码。从上面的讨论可以看出，解决序列化和反射攻击很麻烦，而枚举实现不会出现这两种问题，所以说枚举实现单例模式是最佳实践。 ### 使用场景 - Logger Classes - Configuration Classes - Accesing resources in shared mode - Factories implemented as Singletons ### 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()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--) ## 2. 简单工厂 ### 意图在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。 ### 类图简单工厂不是设计模式，更像是一种编程习惯。它把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个子类来实例化。

这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。因为客户类往往有多个，如果不使用简单工厂，所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。如果存在下面这种代码，就需要使用简单工厂将对象实例化的部分放到简单工厂中。 ```java public class Client { public static void main(String[] args) { int type = 1; Product product; if (type == 1) { product = new ConcreteProduct1(); } else if (type == 2) { product = new ConcreteProduct2(); } else { product = new ConcreteProduct(); } } } ``` ### 实现 ```java public interface Product { } ``` ```java public class ConcreteProduct implements Product { } ``` ```java public class ConcreteProduct1 implements Product { } ``` ```java public class ConcreteProduct2 implements Product { } ``` ```java public class SimpleFactory { public Product createProduct(int type) { if (type == 1) { return new ConcreteProduct1(); } else if (type == 2) { return new ConcreteProduct2(); } return new ConcreteProduct(); } } ``` ```java public class Client { public static void main(String[] args) { SimpleFactory simpleFactory = new SimpleFactory(); Product product = simpleFactory.createProduct(1); } } ``` ## 3. 工厂方法模式 ### 意图定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化推迟到子类。 ### 类图在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。下图中，Factory 有一个 doSomethind() 方法，这个方法需要用到一组产品对象，这组产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

### 实现 ```java public abstract class Factory { abstract public Product factoryMethod(); public void doSomething() { Product product = factoryMethod(); // do something with the product } } ``` ```java public class ConcreteFactory extends Factory { public Product factoryMethod() { return new ConcreteProduct(); } } ``` ```java public class ConcreteFactory1 extends Factory { public Product factoryMethod() { return new ConcreteProduct1(); } } ``` ```java public class ConcreteFactory2 extends Factory { public Product factoryMethod() { return new ConcreteProduct2(); } } ``` ### 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--) - [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-) - [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--) ## 4. 抽象工厂模式 ### 意图提供一个接口，用于创建 **相关的对象家族** 。 ### 类图

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂模式只是用于创建一个对象，这和抽象工厂模式有很大不同。抽象工厂模式用到了工厂模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂模式的定义。至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂模式使用了继承。 ### 代码实现 ```java public class AbstractProductA { } ``` ```java public class AbstractProductB { } ``` ```java public class ProductA1 extends AbstractProductA { } ``` ```java public class ProductA2 extends AbstractProductA { } ``` ```java public class ProductB1 extends AbstractProductB { } ``` ```java public class ProductB2 extends AbstractProductB { } ``` ```java public abstract class AbstractFactory { abstract AbstractProductA createProductA(); abstract AbstractProductB createProductB(); } ``` ```java public class ConcreteFactory1 extends AbstractFactory { AbstractProductA createProductA() { return new ProductA1(); } AbstractProductB createProductB() { return new ProductB1(); } } ``` ```java public class ConcreteFactory2 extends AbstractFactory { AbstractProductA createProductA() { return new ProductA2(); } AbstractProductB createProductB() { return new ProductB2(); } } ``` ```java public class Client { public static void main(String[] args) { AbstractFactory abstractFactory = new ConcreteFactory1(); AbstractProductA productA = abstractFactory.createProductA(); AbstractProductB productB = abstractFactory.createProductB(); // do something with productA and productB } } ``` ### 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--) ## 5. 生成器 ### 意图定义一个新的类来构造另一个类的实例，以创建一个复杂的对象。它可以封装一个对象的构造过程，并允许按步骤构造。 ### 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) ## 6. 原型模式 ### 意图使用原型实例指定要创建对象的类型；通过复制这个原型来创建新对象。 ### JDK - [java.lang.Object#clone()] (http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29) # 三、行为型 ## 1. 责任链 ### 意图避免将请求的发送者附加到其接收者，从而使其它对象也可以处理请求；将请求以对象的方式发送到链上直到请求被处理完毕。 ### 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/proper/commons-chain/index.html) - [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-) ## 2. 命令模式 ### 意图将命令封装进对象中；允许使用命令对象对客户对象进行参数化；允许将命令对象存放到队列中。 ### 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) ## 3. 解释器模式 ### 意图为语言创建解释器，通常由语言的语法和语法分析来定义。 ### 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) ## 4. 迭代器 ### 意图提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。 ### 类图 - Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator； - Iterator 主要定义了 hasNext() 和 next() 方法。 - Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。

### 实现 ```java public interface Aggregate { Iterator createIterator(); } ``` ```java public class ConcreteAggregate implements Aggregate { private Integer[] items; public ConcreteAggregate() { items = new Integer[10]; for (int i = 0; i < items.length; i++) { items[i] = i; } } @Override public Iterator createIterator() { return new ConcreteIterator(items); } } ``` ```java public interface Iterator { Item next(); boolean hasNext(); } ``` ```java public class ConcreteIterator implements Iterator { private Item[] items; private int position = 0; public ConcreteIterator(Item[] items) { this.items = items; } @Override public Object next() { return items[position++]; } @Override public boolean hasNext() { return position < items.length; } } ``` ```java public class Client { public static void main(String[] args) { Aggregate aggregate = new ConcreteAggregate(); Iterator iterator = aggregate.createIterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } } } ``` ### 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) ## 5. 中间人模式 ### 意图使用中间人对象来封装对象之间的交互。中间人模式可以降低交互对象之间的耦合程度。 ### 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...-) ## 6. 备忘录模式 ### 意图在不违反封装的情况下获得对象的内部状态，从而在需要时可以将对象恢复到最初状态。 ### JDK - [java.util.Date](http://docs.oracle.com/javase/8/docs/api/java/util/Date.html) ## 7. 观察者模式 ### 意图定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且自动更新状态。 ### 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) ## 8. 策略模式 ### 意图定义一系列算法，封装每个算法，并使它们可以互换。策略可以让算法独立于使用它的客户端。 ### JDK - java.util.Comparator#compare() - javax.servlet.http.HttpServlet - javax.servlet.Filter#doFilter() ## 9. 模板方法 ### 意图定义算法框架，并将一些步骤的实现延迟到子类。通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。 ### 类图

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

```java public abstract class CaffeineBeverage { final void prepareRecipe() { boilWater(); brew(); pourInCup(); addCondiments(); } abstract void brew(); abstract void addCondiments(); void boilWater() { System.out.println("boilWater"); } void pourInCup() { System.out.println("pourInCup"); } } ``` ```java public class Coffee extends CaffeineBeverage{ @Override void brew() { System.out.println("Coffee.brew"); } @Override void addCondiments() { System.out.println("Coffee.addCondiments"); } } ``` ```java public class Tea extends CaffeineBeverage{ @Override void brew() { System.out.println("Tea.brew"); } @Override void addCondiments() { System.out.println("Tea.addCondiments"); } } ``` ```java public class Client { public static void main(String[] args) { CaffeineBeverage caffeineBeverage = new Coffee(); caffeineBeverage.prepareRecipe(); System.out.println("-----------"); caffeineBeverage = new Tea(); caffeineBeverage.prepareRecipe(); } } ``` ```html boilWater Coffee.brew pourInCup Coffee.addCondiments ----------- boilWater Tea.brew pourInCup Tea.addCondiments ``` ### JDK - java.util.Collections#sort() - java.io.InputStream#skip() - java.io.InputStream#read() - java.util.AbstractList#indexOf() ## 10. 访问者模式 ### 意图提供便捷的维护方式来操作一组对象。它使你在不改变操作对象的前提下，可以修改或扩展对象的行为。例如集合，它可以包含不同类型的元素，访问者模式允许在不知道具体元素类型的前提下对集合元素进行一些操作。 ### JDK - javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor - javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor ## 11. 空对象模式 ### 意图使用什么都不做的空对象来替代 NULL。一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。 ### 类图

### 实现 ```java public abstract class AbstractOperation { abstract void request(); } ``` ```java public class RealOperation extends AbstractOperation { @Override void request() { System.out.println("do something"); } } ``` ```java public class NullOperation extends AbstractOperation{ @Override void request() { // do nothing } } ``` ```java public class Client { public static void main(String[] args) { AbstractOperation abstractOperation = func(-1); abstractOperation.request(); } public static AbstractOperation func(int para) { if (para < 0) { return new NullOperation(); } return new RealOperation(); } } ``` # 四、结构型 ## 1. 适配器模式 ### 意图把一个类接口转换成另一个用户需要的接口。

### 类图

### 实现鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！ ```java public interface Duck { void quack(); } ``` ```java public interface Turkey { void gobble(); } ``` ```java public class WildTurkey implements Turkey { @Override public void gobble() { System.out.println("gobble!"); } } ``` ```java public class TurkeyAdapter implements Duck { Turkey turkey; public TurkeyAdapter(Turkey turkey) { this.turkey = turkey; } @Override public void quack() { turkey.gobble(); } } ``` ```java public class Client { public static void main(String[] args) { Turkey turkey = new WildTurkey(); Duck duck = new TurkeyAdapter(turkey); duck.quack(); } } ``` ### 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-) ## 2. 桥接模式 ### 意图将抽象与实现分离开来，使它们可以独立变化。 ### JDK - AWT (It provides an abstraction layer which maps onto the native OS the windowing support.) - JDBC ## 3. 组合模式 ### 意图将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。 ### 类图组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。

### 实现 ```java public abstract class Component { protected String name; public Component(String name) { this.name = name; } public void print() { print(0); } abstract void print(int level); abstract public void add(Component component); abstract public void remove(Component component); } ``` ```java import java.util.ArrayList; import java.util.List; public class Composite extends Component { private List child; public Composite(String name) { super(name); child = new ArrayList<>(); } @Override void print(int level) { for (int i = 0; i < level; i++) { System.out.print("--"); } System.out.println("Composite:" + name); for (Component component : child) { component.print(level + 1); } } @Override public void add(Component component) { child.add(component); } @Override public void remove(Component component) { child.remove(component); } } ``` ```java public class Leaf extends Component { public Leaf(String name) { super(name); } @Override void print(int level) { for (int i = 0; i < level; i++) { System.out.print("--"); } System.out.println("left:" + name); } @Override public void add(Component component) { throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点 } @Override public void remove(Component component) { throw new UnsupportedOperationException(); } } ``` ```java public class Client { public static void main(String[] args) { Composite root = new Composite("root"); Component node1 = new Leaf("1"); Component node2 = new Composite("2"); Component node3 = new Leaf("3"); root.add(node1); root.add(node2); root.add(node3); Component node21 = new Leaf("21"); Component node22 = new Composite("22"); node2.add(node21); node2.add(node22); Component node221 = new Leaf("221"); node22.add(node221); root.print(); } } ``` ```html Composite:root --left:1 --Composite:2 ----left:21 ----Composite:22 ------left:221 --left:3 ``` ### 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) ## 4. 装饰者模式 ### 意图为对象动态添加功能。 ### 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]() ## 5. 蝇量模式 ### 意图利用共享的方式来支持大量的对象，这些对象一部分内部状态是相同的，而另一份状态可以变化。 ### JDK Java 利用缓存来加速大量小对象的访问时间。 - java.lang.Integer#valueOf(int) - java.lang.Boolean#valueOf(boolean) - java.lang.Byte#valueOf(byte) - java.lang.Character#valueOf(char) ## 6. 动态代理 ### 意图提供一个占位符来控制对象的访问。代理可以是一些轻量级的对象，它控制着对重量级对象的访问，只有在真正实例化这些重量级对象时才会去实例化它。 ### JDK - java.lang.reflect.Proxy - RMI # 参考资料 - 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007. - [Design Patterns](http://www.oodesign.com/) - [Design patterns implemented in Java](http://java-design-patterns.com/) - [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)