JDK中所使用到的设计模式

在JDK类库中，开发人员使用了大量设计模式，正因为如此，可以在不修改JDK源码的前提下开发出自己的应用软件。

1.1创建型模式：
(1) 抽象工厂模式(通过创造性的方法来识别工厂本身，这又可以用于创建另一个抽象/接口类型)

抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不用指定具体对象的类型。它使得应用程序能够和使用的框架的具体实现进行解耦。任何用于创建对象但返回接口或抽象类的，就是抽象工厂模式了。​​​​​​​

Java.util.Calendar#getInstance()

 java.util.Arrays#asList()

 java.util.ResourceBundle#getBundle()

 java.NET.URL#openConnection()

java.sql.DriverManager#getConnection()

 java.sql.Connection#createStatement()

 java.sql.Statement#executeQuery()

 java.text.NumberFormat#getInstance()

 java.lang.management.ManagementFactory (所有getXXX()方法)

 java.nio.charset.Charset#forName()

javax.xml.parsers.DocumentBuilderFactory#newInstance()

 javax.xml.transform.TransformerFactory#newInstance()

 javax.xml.xpath.XPathFactory#newInstance()

(2) 建造者模式（通过创建方法识别返回实例本身）​​​​​​​

用于通过定义一个类来简化复杂对象的创建，该类的目的是构建另一个类的实例。构建器模式还允许实现Fluent接口

java.lang.StringBuilder#append()  （非线程安全）

 java.lang.StringBuffer#append()  （线程安全）

java.nio.ByteBuffer#put() (CharBuffer, ShortBuffer,IntBuffer,LongBuffer, FloatBuffer 和DoubleBuffer与之类似)

 javax.swing.GroupLayout.Group#addComponent()

 java.sql.PreparedStatement

 java.lang.Appendable的所有实现类

(3) 工厂方法模式（可通过创建方法识别返回抽象/接口类型的实现）

只是一个返回实际类型的方法。

java.lang.Object#toString() (在其子类中可以覆盖该方法)

 java.lang.Class#newInstance()

 java.lang.Integer#valueOf(String) (Boolean, Byte,Character,Short, Long, Float 和 Double与之类似)

 java.lang.Class#forName()

 java.lang.reflect.Array#newInstance()

java.lang.reflect.Constructor#newInstance()

(4) 原型模式（通过创建方法识别，返回具有相同属性的其他实例）

使得类的实例能够生成自身的拷贝。如果创建一个对象的实例非常复杂且耗时时，就可以使用这种模式，而不重新创建一个新的实例，你可以拷贝一个对象并直接修改它。

java.lang.Object#clone() (支持浅克隆的类必须实现java.lang.Cloneable接口)

(5) 单例模式（用来确保类只有一个实例）

java.lang.Runtime#getRuntime()

 java.awt.Desktop#getDesktop()

3.2结构型模式：
(1) 适配器模式（可通过创建方法识别采用不同抽象/接口类型的实例，并返回自己/另一个抽象/接口类型的实现，其装饰/覆盖给定实例）

常用于将一个新接口适配旧接口

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

(2) 桥接模式（可以通过创建方法识别采用不同抽象/接口类型的实例，并返回自己的使用给定实例的抽象/接口类型的实现）

将抽象和抽象的具体实现进行解耦，这样可以使得抽象和抽象的具体实现可以独立进行变化。

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

JDBC

(3) 组合模式（通过将具有相同抽象/接口类型的实例的行为方法识别为树结构）

让客户端看起来在处理单个对象和对象的组合是平等的，换句话说，某个类型的方法同时也接受自身类型作为参数。

组合模式常用于递归操作的优化上​​​​​​​

avax.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.InputStream，OutputStream，Reader并Writer有一个构造函数取相同类型的实例。

java.util.Collections的checkedXXX()，synchronizedXXX()和unmodifiableXXX()方法。

javax.servlet.http.HttpServletRequestWrapper 和 HttpServletResponseWrapper

(5) 外观模式（可通过内部使用不同独立抽象/接口类型实例的行为方法识别）

为一组组件，接口，抽象或子系统提供简化的接口。

java.lang.Class

javax.faces.webapp.FacesServlet

(6) 享元模式

使用缓存来减少对小对象的访问时间

java.lang.Integer#valueOf(int)

java.lang.Boolean#valueOf(boolean)

java.lang.Byte#valueOf(byte)

java.lang.Character#valueOf(char)

(7) 代理模式（可通过创建方法识别，该方法返回给定的抽象/接口类型的实现，该类型依次代表/使用给定抽象/接口类型的不同实现）

代理模式用于向较简单的对象代替创建复杂或耗时的对象。

 java.lang.reflect.Proxy

java.rmi.*

3.3行为型模式：
(1) 职责链模式（通过行为方法识别（间接地）在队列中的相同抽象/接口类型的另一个实现中调用相同的方法）​​​​​​​

通过把请求从一个对象传递到链条中下一个对象的方式来解除对象之间的耦合，直到请求被处理完毕。链中的对象是同一接口或抽象类的不同实现。​​​​​​​
java.util.logging.Logger#log()

javax.servlet.Filter#doFilter()

(2) 命令模式（可以通过抽象/接口类型中的行为方法识别，该方法在创建时由命令实现封装的不同抽象/接口类型的实现中调用方法）​​​​​​​

将命令包装在对象中，以便可以将其存储，传递到方法中，并像任何其他对象一样返回。​​​​​​​
java.lang.Runnable

javax.swing.Action

(3) 解释器模式（通过行为方法识别，返回结构不同的实例/给定实例/类型的类型;请注意，解析/格式化不是模式的一部分，确定模式以及如何应用它）
java.util.Pattern

java.text.Normalizer

java.text.Format

javax.el.ELResolver

(4) 迭代器模式（可通过行为方法识别，从队列中顺序返回不同类型的实例）

提供一个统一的方式来访问集合中的对象。
java.util.Iterator

java.util.Enumeration

(5) 中介者模式（通过采用不同的抽象/接口类型（通常使用命令模式）实例的行为方法来识别给定实例）

通过使用一个中间对象来进行消息分发以及减少类之间的直接依赖。
java.util.Timer (所有scheduleXXX()方法)

java.util.concurrent.Executor#execute()

java.util.concurrent.ExecutorService (invokeXXX()和submit()方法)

java.util.concurrent.ScheduledExecutorService (所有scheduleXXX()方法)

java.lang.reflect.Method#invoke()

(6) 备忘录模式（可以通过内部改变整个实例的状态的行为方法来识别）

生成对象状态的一个快照，以便对象可以恢复原始状态而不用暴露自身的内容。比如Date对象通过自身内部的一个long值来实现备忘录模式。
java.util.Date

java.io.Serializable

javax.faces.component.StateHolder

(7) 观察者模式（可以通过行为方法识别，根据自己的状态调用另一个抽象/接口类型的实例上的方法）

用于为组件提供一种灵活地向感兴趣的接收者广播消息的方式。
java.util.Observer/java.util.Observable

java.util.EventListener (所有子类)

javax.servlet.http.HttpSessionBindingListener

javax.servlet.http.HttpSessionAttributeListener

javax.faces.event.PhaseListener

(8) 状态模式（可以通过行为方法识别，根据可以从外部控制的实例的状态改变其行为）

允许在运行时根据内部状态轻松更改对象的行为。
java.util.Iterator

javax.faces.lifecycle.LifeCycle#execute()

(9) 策略模式（可以通过抽象/接口类型中的行为方法识别，该方法在已经作为方法参数传递到策略实现中的不同抽象/接口类型的实现中调用方法）

使用这个模式来将一组算法封装成一系列对象。通过调用这些对象可以灵活的改变程序的功能。

 java.util.Comparator#compare()

javax.servlet.http.HttpServlet

javax.servlet.Filter#doFilter()

(10) 模板方法模式（可以由已经具有抽象类型定义的“默认”行为的行为方法识别）

让子类可以重写方法的一部分，而不是整个重写，你可以控制子类需要重写那些操作。
java.io.InputStream, java.io.OutputStream, java.io.Reader和java.io.Writer的所有非抽象方法

java.util.AbstractList, java.util.AbstractSet和java.util.AbstractMap的所有非抽象方法

javax.servlet.http.HttpServlet#doXXX()

(11) 访问者模式（可以通过两种不同的抽象/接口类型识别，它们的方法定义为采用每个其他抽象/接口类型;实际上调用另一个抽象/接口类型的方法，另一个执行所需的策略）

提供一个方便的可维护的方式来操作一组对象。它使得你在不改变操作的对象前提下，可以修改或者扩展对象的行为。 
javax.lang.model.element.AnnotationValue和AnnotationValueVisitor

javax.lang.model.element.Element和ElementVisitor

javax.lang.model.type.TypeMirror和TypeVisitor