• 一、创建型
    • 1. 单例模式
    • 2. 简单工厂模式
    • 3. 工厂方法模式
    • 4. 抽象工厂
    • 5. 生成器模式
    • 6. 原型模式
  • 二、行为型
    • 1. 责任链
    • 2. 命令模式
    • 3. 解释器模式
    • 4. 迭代器
    • 5. 中间人模式
    • 6. 备忘录模式
    • 7. 观察者模式
    • 8. 策略模式
    • 9. 模板方法
    • 10. 访问者模式
    • 11. 空对象模式
  • 三、结构型
    • 1. 适配器
    • 2. 桥接模式
    • 3. 组合模式
    • 4. 装饰者模式
    • 5. 蝇量模式
    • 6. 动态代理
  • 参考资料

    一、创建型

    1. 单例模式

    确保只实例化一个对象，并提供一个对象的全局访问点。

    1. java.lang.Runtime#getRuntime()
    2. java.awt.Toolkit#getDefaultToolkit()
    3. java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
    4. java.awt.Desktop#getDesktop()

    2. 简单工厂模式

    在不对用户暴露对象内部逻辑的前提下创建对象；使用通用的接口来创建对象；

    3. 工厂方法模式

    定义创建对象的接口，但是让子类来决定应该使用哪个类来创建；使用通用的接口来创建对象；

    1. java.lang.Proxy#newProxyInstance()
    2. java.lang.Object#toString()
    3. java.lang.Class#newInstance()
    4. java.lang.reflect.Array#newInstance()
    5. java.lang.reflect.Constructor#newInstance()
    6. java.lang.Boolean#valueOf(String)
    7. java.lang.Class#forName()

    4. 抽象工厂

    提供一个创建相关对象家族的接口，而没有明确指明它们的类。

    1. java.util.Calendar#getInstance()
    2. java.util.Arrays#asList()
    3. java.util.ResourceBundle#getBundle()
    4. java.sql.DriverManager#getConnection()
    5. java.sql.Connection#createStatement()
    6. java.sql.Statement#executeQuery()
    7. java.text.NumberFormat#getInstance()
    8. javax.xml.transform.TransformerFactory#newInstance()

    5. 生成器模式

    定义一个新的类来构造另一个类的实例，以创建一个复杂的对象。

    它可以封装一个对象的构造过程，并允许按步骤构造。

    1. java.lang.StringBuilder#append()
    2. java.lang.StringBuffer#append()
    3. java.sql.PreparedStatement
    4. javax.swing.GroupLayout.Group#addComponent()

    6. 原型模式

    使用原型实例指定要创建对象的类型；通过复制这个原型来创建新对象。

    1. java.lang.Object#clone()
    2. java.lang.Cloneable

    二、行为型

    1. 责任链

    避免将请求的发送者附加到其接收者，从而使其它对象也可以处理请求；将请求以对象的方式发送到链上直到请求被处理完毕。

    1. java.util.logging.Logger#log()
    2. javax.servlet.Filter#doFilter()

    2. 命令模式

    将命令封装进对象中；允许使用命令对象对客户对象进行参数化；允许将命令对象存放到队列中。

    1. java.lang.Runnable
    2. javax.swing.Action

    3. 解释器模式

    为语言创建解释器，通常由语言的语法和语法分析来定义。

    1. java.util.Pattern
    2. java.text.Normalizer
    3. java.text.Format

    4. 迭代器

    提供一种一致的访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。

    1. java.util.Iterator
    2. java.util.Enumeration

    5. 中间人模式

    使用中间人对象来封装对象之间的交互。中间人模式可以让降低交互对象之间的耦合程度。

    1. java.util.Timer
    2. java.util.concurrent.Executor#execute()
    3. java.util.concurrent.ExecutorService#submit()
    4. java.lang.reflect.Method#invoke()

    6. 备忘录模式

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

    1. java.util.Date
    2. java.io.Serializable

    7. 观察者模式

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

    1. java.util.EventListener
    2. javax.servlet.http.HttpSessionBindingListener
    3. javax.servlet.http.HttpSessionAttributeListener
    4. javax.faces.event.PhaseListener

    8. 策略模式

    定义一系列算法，封装每个算法，并使它们可以互换。策略可以让算法独立于使用它的客户端。

    1. java.util.Comparator#compare()
    2. javax.servlet.http.HttpServlet
    3. javax.servlet.Filter#doFilter()

    9. 模板方法

    定义算法框架，并将一些步骤的实现延迟到子类。通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。

    1. java.util.Collections#sort()
    2. java.io.InputStream#skip()
    3. java.io.InputStream#read()
    4. java.util.AbstractList#indexOf()

    10. 访问者模式

    提供便捷的维护方式来操作一组对象。它使你在不改变操作对象的前提下，可以修改或扩展对象的行为。

    例如集合，它可以包含不同类型的元素，访问者模式允许在不知道具体元素类型的前提下对集合元素进行一些操作。

    1. javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
    2. javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor

    11. 空对象模式

    使用什么都不做的空对象来替代 NULL。

    三、结构型

    1. 适配器

    把一个类接口转换成另一个用户需要的接口。

    1. java.util.Arrays#asList()
    2. javax.swing.JTable(TableModel)
    3. java.io.InputStreamReader(InputStream)
    4. java.io.OutputStreamWriter(OutputStream)
    5. javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
    6. javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()

    2. 桥接模式

    将抽象与实现分离开来，使它们可以独立变化。

    1. AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
    2. JDBC

    3. 组合模式

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

    1. javax.swing.JComponent#add(Component)
    2. java.awt.Container#add(Component)
    3. java.util.Map#putAll(Map)
    4. java.util.List#addAll(Collection)
    5. java.util.Set#addAll(Collection)

    4. 装饰者模式

    为对象动态添加功能。

    1. java.io.BufferedInputStream(InputStream)
    2. java.io.DataInputStream(InputStream)
    3. java.io.BufferedOutputStream(OutputStream)
    4. java.util.zip.ZipOutputStream(OutputStream)
    5. java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()

    5. 蝇量模式

    利用共享的方式来支持大量的对象，这些对象一部分内部状态是相同的，而另一份状态可以变化。

    Java 利用缓存来加速大量小对象的访问时间。

    1. java.lang.Integer#valueOf(int)
    2. java.lang.Boolean#valueOf(boolean)
    3. java.lang.Byte#valueOf(byte)
    4. java.lang.Character#valueOf(char)

    6. 动态代理

    提供一个占位符来控制对象的访问。

    代理可以是一些轻量级的对象，它控制着对重量级对象的访问，只有在真正实例化这些重量级对象时才会去实例化它。

    1. java.lang.reflect.Proxy
    2. RMI

    参考资料

    • The breakdown of design patterns in JDK
    • Design Patterns