求设计模式（Gof） 简单例子，语言最好是java的。
这个问题在stackoverflow有一个非常好的答案，这里我把BalusC的答案翻译整理下（英语好的可以无视）：首先Gof的各种设计模式的基本概念可以看Wiki. 下面的例子都是来自Java SE 和 Java EE API 。
【抽象工厂模式】(为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候，可以从抽象工厂中选出相应的系列创建一个具体的工厂类。)javax.xml.parsers.DocumentBuilderFactory#newInstance()javax.xml.transform.TransformerFactory#newInstance()javax.xml.xpath.XPathFactory#newInstance()
【生成器模式】(通过一个方法来返回实例本身)java.lang.StringBuilder#append() (unsynchronized)java.lang.StringBuffer#append() (synchronized)java.nio.ByteBuffer#put() (类似还有 CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer , DoubleBuffer)javax.swing.GroupLayout.Group#addComponent()All implementations of java.lang.Appendable
【工厂方法模式】(通过一个方法返回抽象类或接口类型 abstract/interface type的一个实现)java.util.Calendar#getInstance()java.util.ResourceBundle#getBundle()java.text.NumberFormat#getInstance()java.nio.charset.Charset#forName()java.net.URLStreamHandlerFactory#createURLStreamHandler(String)
【原型模式】 (通过一个方法返回同一个类的不同实例{传入相同参数的情况下})java.lang.Object#clone() (对应的类必需实现这个接口 java.lang.Cloneable)
【单例模式】(这个方法每次都返回相同的实例)java.lang.Runtime#getRuntime()java.awt.Desktop#getDesktop()
【适配器模式】(将某个类的接口转换成客户端期望的另一个接口表示。适配器模式可以消除由于接口不匹配所造成的类兼容性问题)java.util.Arrays#asList()java.io.InputStreamReader(InputStream)java.io.OutputStreamWriter(OutputStream)javax.xml.bind.annotation.adapters.XmlAdapter#marshal() 和 #unmarshal()
【桥接模式】（将一个抽象与实现解耦，以便两者可以独立的变化。）暂时想不出很好的现成例子. 一个虚构的例子： 一个方法可以构造一个新LinkedHashMap(LinkedHashSet, List) 并且是一个不可改变的 linked map （没有克隆 items, 直接使用他们）. java.util.Collections#newSetFromMap() 和 singletonXXX() 都比较接近.
【组合模式】 (把多个对象组成树状结构来表示局部与整体，这样用户可以一样的对待单个对象和对象的组合。)java.awt.Container#add(Component)javax.faces.component.UIComponent#getChildren()
【修饰模式】(向某个对象动态地添加更多的功能。修饰模式是除类继承外另一种扩展功能的方法。)所有java.io.InputStream, OutputStream, Reader and Writer的子类，都有一个构造方法（同样的参数）.java.util.Collections, checkedXXX(), synchronizedXXX() 和 unmodifiableXXX() 方法.javax.servlet.http.HttpServletRequestWrapper 和 HttpServletResponseWrapper
【门面模式】 (为子系统中的一组接口提供一个一致的界面)javax.faces.context.FacesContextjavax.faces.context.ExternalContext
【享元】 (通过共享以便有效的支持大量小颗粒对象。)java.lang.Integer#valueOf(int) (also on Boolean, Byte, Character, Short and Long)
【代理模式】 (为其他对象提供一个代理以控制对这个对象的访问。)java.lang.reflect.Proxyjava.rmi.*, 所有的API.
【责任链】 (为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。)java.util.logging.Logger#log()javax.servlet.Filter#doFilter()
【命令】(将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。)java.lang.Runnable 的所有实现javax.swing.Action 的所有实现
【解释器】(给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。)java.util.Patternjava.text.Normalizerjava.text.Format的所有子类javax.el.ELResolver的所有子类
【迭代器】(提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。)java.util.Iterator的所有实现java.util.Enumeration的所有实现
【中介者】(包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用，从而使它们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用，保证这些作用可以彼此独立的变化。)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()
【备忘录】(备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。)java.util.Date (setter 方法是这样实现的, 在内部实现中Date相当于一个long值)java.io.Serializable 所有实现javax.faces.component.StateHolder 所有实现
【观察者模式】 (在对象间定义一个一对多的联系性，由此当一个对象改变了状态，所有其他相关的对象会被通知并且自动刷新。)java.util.Observer/java.util.Observable (尽管在现实中很少用到)java.util.EventListener 所有实现javax.servlet.http.HttpSessionBindingListenerjavax.servlet.http.HttpSessionAttributeListenerjavax.faces.event.PhaseListener
【状态】 (让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。)javax.faces.lifecycle.LifeCycle#execute() (被FacesServlet所控制, 它的行为依赖于当前的JSF生命周期的每一个阶段{state})
【策略】(定义一个算法的系列，将其各个分装，并且使他们有交互性。策略模式使得算法在用户使用的时候能独立的改变。)java.util.Comparator#compare(), 通过 Collections#sort()方法来执行.javax.servlet.http.HttpServlet, service() 方法和所有的 doXXX() 方法把 HttpServletRequest 和 HttpServletResponse 以及他们的实现当做参数来执行 (并没有把他们持有为成员变量!).javax.servlet.Filter#doFilter()
【模板方法】 (模板方法模式准备一个抽象类，将部分逻辑以具体方法及具体构造子类的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先构建一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。)java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer的所有非抽象的方法.java.util.AbstractList, java.util.AbstractSet and java.util.AbstractMap的所有非抽象的方法.
【访问者】 (封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。)javax.lang.model.element.AnnotationValue 和 AnnotationValueVisitorjavax.lang.model.element.Element 和 ElementVisitorjavax.lang.model.type.TypeMirror 和 TypeVisitor
23个全来一遍? 呵呵.
其实对这个问题来说, java类库本身提供了大量的gof pattern的例子. 你看看sof上的这个神级答案:http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
暂无简介
文章 0 评论 0
接受
发布评论
评论（2）
这个问题在stackoverflow有一个非常好的答案，这里我把BalusC的答案翻译整理下（英语好的可以无视）：
首先Gof的各种设计模式的基本概念可以看Wiki. 下面的例子都是来自Java SE 和 Java EE API 。
创建型模式
【抽象工厂模式】(为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候，可以从抽象工厂中选出相应的系列创建一个具体的工厂类。)
javax.xml.parsers.DocumentBuilderFactory#newInstance()
javax.xml.transform.TransformerFactory#newInstance()
javax.xml.xpath.XPathFactory#newInstance()
【生成器模式】(通过一个方法来返回实例本身)
java.lang.StringBuilder#append() (unsynchronized)
java.lang.StringBuffer#append() (synchronized)
java.nio.ByteBuffer#put() (类似还有 CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer , DoubleBuffer)
javax.swing.GroupLayout.Group#addComponent()
All implementations of java.lang.Appendable
【工厂方法模式】(通过一个方法返回抽象类或接口类型 abstract/interface type的一个实现)
java.util.Calendar#getInstance()
java.util.ResourceBundle#getBundle()
java.text.NumberFormat#getInstance()
java.nio.charset.Charset#forName()
java.net.URLStreamHandlerFactory#createURLStreamHandler(String)
【原型模式】 (通过一个方法返回同一个类的不同实例{传入相同参数的情况下})
java.lang.Object#clone() (对应的类必需实现这个接口 java.lang.Cloneable)
【单例模式】(这个方法每次都返回相同的实例)
java.lang.Runtime#getRuntime()
java.awt.Desktop#getDesktop()
结构型模式
【适配器模式】(将某个类的接口转换成客户端期望的另一个接口表示。适配器模式可以消除由于接口不匹配所造成的类兼容性问题)
java.util.Arrays#asList()
java.io.InputStreamReader(InputStream)
java.io.OutputStreamWriter(OutputStream)
javax.xml.bind.annotation.adapters.XmlAdapter#marshal() 和 #unmarshal()
【桥接模式】（将一个抽象与实现解耦，以便两者可以独立的变化。）, List) 并且是一个不可改变的 linked map （没有克隆 items, 直接使用他们）. java.util.Collections#newSetFromMap() 和 singletonXXX() 都比较接近.
暂时想不出很好的现成例子. 一个虚构的例子： 一个方法可以构造一个新LinkedHashMap(LinkedHashSet
【组合模式】 (把多个对象组成树状结构来表示局部与整体，这样用户可以一样的对待单个对象和对象的组合。)
java.awt.Container#add(Component)
javax.faces.component.UIComponent#getChildren()
【修饰模式】(向某个对象动态地添加更多的功能。修饰模式是除类继承外另一种扩展功能的方法。)
所有java.io.InputStream, OutputStream, Reader and Writer的子类，都有一个构造方法（同样的参数）.
java.util.Collections, checkedXXX(), synchronizedXXX() 和 unmodifiableXXX() 方法.
javax.servlet.http.HttpServletRequestWrapper 和 HttpServletResponseWrapper
【门面模式】 (为子系统中的一组接口提供一个一致的界面)
javax.faces.context.FacesContext
javax.faces.context.ExternalContext
【享元】 (通过共享以便有效的支持大量小颗粒对象。)
java.lang.Integer#valueOf(int) (also on Boolean, Byte, Character, Short and Long)
【代理模式】 (为其他对象提供一个代理以控制对这个对象的访问。)
java.lang.reflect.Proxy
java.rmi.*, 所有的API.
行为型模式
【责任链】 (为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。)
java.util.logging.Logger#log()
javax.servlet.Filter#doFilter()
【命令】(将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。)
java.lang.Runnable 的所有实现
javax.swing.Action 的所有实现
【解释器】(给定一个语言, 定义它的文法的一种表示，并定义一个解释器, 该解释器使用该表示来解释语言中的句子。)
java.util.Pattern
java.text.Normalizer
java.text.Format的所有子类
javax.el.ELResolver的所有子类
【迭代器】(提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。)
java.util.Iterator的所有实现
java.util.Enumeration的所有实现
【中介者】(包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用，从而使它们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用，保证这些作用可以彼此独立的变化。)
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()
【备忘录】(备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。)
java.util.Date (setter 方法是这样实现的, 在内部实现中Date相当于一个long值)
java.io.Serializable 所有实现
javax.faces.component.StateHolder 所有实现
【观察者模式】 (在对象间定义一个一对多的联系性，由此当一个对象改变了状态，所有其他相关的对象会被通知并且自动刷新。)
java.util.Observer/java.util.Observable (尽管在现实中很少用到)
java.util.EventListener 所有实现
javax.servlet.http.HttpSessionBindingListener
javax.servlet.http.HttpSessionAttributeListener
javax.faces.event.PhaseListener
【状态】 (让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。)
javax.faces.lifecycle.LifeCycle#execute() (被FacesServlet所控制, 它的行为依赖于当前的JSF生命周期的每一个阶段{state})
【策略】(定义一个算法的系列，将其各个分装，并且使他们有交互性。策略模式使得算法在用户使用的时候能独立的改变。)
java.util.Comparator#compare(), 通过 Collections#sort()方法来执行.
javax.servlet.http.HttpServlet, service() 方法和所有的 doXXX() 方法把 HttpServletRequest 和 HttpServletResponse 以及他们的实现当做参数来执行 (并没有把他们持有为成员变量!).
javax.servlet.Filter#doFilter()
【模板方法】 (模板方法模式准备一个抽象类，将部分逻辑以具体方法及具体构造子类的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先构建一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。)
java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer的所有非抽象的方法.
java.util.AbstractList, java.util.AbstractSet and java.util.AbstractMap的所有非抽象的方法.
【访问者】 (封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。)
javax.lang.model.element.AnnotationValue 和 AnnotationValueVisitor
javax.lang.model.element.Element 和 ElementVisitor
javax.lang.model.type.TypeMirror 和 TypeVisitor
23个全来一遍? 呵呵.
其实对这个问题来说, java类库本身提供了大量的gof pattern的例子. 你看看sof上的这个神级答案:
http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns