JDK里的设计模式

JDK中有关23个经典设计模式的示例

Structural（结构型模式）

Adapter (适配器模式):将一个类的接口转换成客户希望的另一个接口,适配器模式让那些接口不兼容的类可以一起工作。

• java.util.Arrays#asList()
• javax.swing.JTable(TableModel)
• java.io.InputStreamReader(InputStream)
• java.io.OutputStreamWriter(OutputStream)
• javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
• javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()

Bridge (桥接模式):将抽象部分与它的实现部分解耦，使得两者都能够独立变化。

• AWT (提供了抽象层映射于实际的操作系统)
• JDBC

Composite (组合模式):组合多个对象形成树形结构，以表示具有部分-整体关系的层次结构。组合模式让客户端可以统一对待单个对象和组合对象。

• 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)

Decorator (装饰模式):动态地给一个对象增加一些额外的职责。就扩展功能而言，装饰模式提供了一种比使用子类更加灵活的替代方案。

• 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]()

Facade (外观模式):为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

• java.lang.Class
• javax.faces.webapp.FacesServlet

Flyweight (享元模式):运用共享技术有效地支持大量细粒度对象的复用。

• java.lang.Integer#valueOf(int)
• java.lang.Boolean#valueOf(boolean)
• java.lang.Byte#valueOf(byte)
• java.lang.Character#valueOf(char)

Proxy (代理模式):给某一个对象提供一个代理或占位符，并由代理对象来控制对原对象的访问。或用一个简单的对象来代替一个复杂的对象。

• java.lang.reflect.Proxy
• RMI

Creational（创建型模式）

Abstract factory (抽象工厂模式):提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。创建一组有关联的对象实例。这个模式在JDK中也是相当的常见，还有很多的framework例如Spring。我们很容易找到这样的实例。

• java.util.Calendar#getInstance()
• java.util.Arrays#asList()
• java.util.ResourceBundle#getBundle()
• java.sql.DriverManager#getConnection()
• java.sql.Connection#createStatement()
• java.sql.Statement#executeQuery()
• java.text.NumberFormat#getInstance()
• javax.xml.transform.TransformerFactory#newInstance()

Builder (建造者模式):将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

    主要用来简化一个复杂的对象的创建。这个模式也可以用来实现一个 Fluent Interface。

• java.lang.StringBuilder#append()
• java.lang.StringBuffer#append()
• java.sql.PreparedStatement
• javax.swing.GroupLayout.Group#addComponent()

Factory (工厂模式):定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

    简单来说，按照需求返回一个类型的实例。

• java.lang.Proxy#newProxyInstance()
• java.lang.Object#toString()
• java.lang.Class#newInstance()
• java.lang.reflect.Array#newInstance()
• java.lang.reflect.Constructor#newInstance()
• java.lang.Boolean#valueOf(String)
• java.lang.Class#forName()

Prototype (原型模式):使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。

    使用自己的实例创建另一个实例。有时候，创建一个实例然后再把已有实例的值拷贝过去，是一个很复杂的动作。所以，使用这个模式可以避免这样的复杂性。

• java.lang.Object#clone()
• java.lang.Cloneable

Singleton (单例模式):确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。

    只允许一个实例。在 Effective Java中建议使用Emun。

• java.lang.Runtime#getRuntime()
• java.awt.Toolkit#getDefaultToolkit()
• java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
• java.awt.Desktop#getDesktop()

Behavioral(行为型模式)

Chain of responsibility (职责链模式):避免将一个请求的发送者与接收者耦合在一起，让多个对象都有机会处理请求。将接收请求的对象连接成一条链，并且沿着这条链传递请求，直到有一个对象能够处理它为止。

    把一个对象在一个链接传递直到被处理。在这个链上的所有的对象有相同的接口（抽象类）但却有不同的实现。

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

Command (命令模式):将一个请求封装为一个对象，从而让你可以用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。

    把一个或一些命令封装到一个对象中。

• java.lang.Runnable
• javax.swing.Action

Interpreter (解释器模式):给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

    一个语法解释器的模式。

• java.util.Pattern
• java.text.Normalizer
• java.text.Format

Iterator (迭代器模式):提供一种方法顺序访问一个聚合对象中的各个元素，且不用暴露该对象的内部表示。

    提供一种一致的方法来顺序遍历一个容器中的所有元素。

• java.util.Iterator
• java.util.Enumeration

Mediator (中介者模式):定义一个对象来封装一系列对象的交互。中介者模式使各对象之间不需要显式地相互引用，从而使其耦合松散，而且让你可以独立地改变它们之间的交互。

    用来减少对象单的直接通讯的依赖关系。使用一个中间类来管理消息的方向。

• java.util.Timer
• java.util.concurrent.Executor#execute()
• java.util.concurrent.ExecutorService#submit()
• java.lang.reflect.Method#invoke()

Memento (备忘录模式):在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。

    给一个对象的状态做一个快照。Date类在内部使用了一个long型来做这个快照。

• java.util.Date
• java.io.Serializable

Observer (观察者模式):定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象都得到通知并被自动更新

    允许一个对象向所有的侦听的对象广播自己的消息或事件。

• java.util.EventListener
• javax.servlet.http.HttpSessionBindingListener
• javax.servlet.http.HttpSessionAttributeListener
• javax.faces.event.PhaseListener

State (状态模式):允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

    这个模式允许你可以在运行时很容易地根据自身内部的状态改变对象的行为。

• java.util.Iterator
• javax.faces.lifecycle.LifeCycle#execute()

Strategy (策略模式):定义一系列算法，将每一个算法封装起来，并让它们可以相互替换，策略模式让算法可以独立于使用它的客户变化。

    定义一组算法，并把其封装到一个对象中。然后在运行时，可以灵活的使用其中的一个算法。

• java.util.Comparator#compare()
• javax.servlet.http.HttpServlet
• javax.servlet.Filter#doFilter()

Template method (模板方法模式):定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类不改变一个算法的结构即可重定义该算法的某些特定步骤。

    允许子类重载部分父类而不需要完全重写。

• java.util.Collections#sort()
• java.io.InputStream#skip()
• java.io.InputStream#read()
• java.util.AbstractList#indexOf()

Visitor (访问者模式):表示一个作用于某对象结构中的各个元素的操作。访问者模式让你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

    作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作。

• javax.lang.model.element.Element 和javax.lang.model.element.ElementVisitor
• javax.lang.model.type.TypeMirror 和javax.lang.model.type.TypeVisitor