官网参考:http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns
Creational patterns
Abstract factory (recognizeable by creational methods returning an abstract/interface type)
* 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 (all getXXX() methods)
* java.nio.charset.Charset#forName()
* javax.xml.parsers.DocumentBuilderFactory#newInstance()
* javax.xml.transform.TransformerFactory#newInstance()
* javax.xml.xpath.XPathFactory#newInstance()
Builder (recognizeable by creational methods returning the instance itself)
* java.lang.StringBuilder#append() (unsynchronized)
* java.lang.StringBuffer#append() (synchronized)
* java.nio.ByteBuffer#put() (also on CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer and DoubleBuffer)
* javax.swing.GroupLayout.Group#addComponent()
* All implementations of java.lang.Appendable
Factory method (recognizeable by creational methods returning a concrete type)
* java.lang.Object#toString() (overrideable in all subclasses)
* java.lang.Class#newInstance()
* java.lang.Integer#valueOf(String) (also on Boolean, Byte, Character, Short, Long, Float and Double)
* java.lang.Class#forName()
* java.lang.reflect.Array#newInstance()
* java.lang.reflect.Constructor#newInstance()
Prototype (recognizeable by creational methods returning a different instance of itself with the same properties)
* java.lang.Object#clone() (the class has to implement java.lang.Cloneable)
Singleton (recognizeable by creational methods returning the same instance (usually of itself) everytime)
* java.lang.Runtime#getRuntime()
* java.awt.Desktop#getDesktop()
Structural patterns
Adapter (recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own/another abstract/interface type which decorates/overrides the given instance)
* java.io.InputStreamReader(InputStream) (returns a Reader)
* java.io.OutputStreamWriter(OutputStream) (returns a Writer)
* javax.xml.bind.annotation.adapters.XmlAdapter#marshal() and #unmarshal()
Bridge (recognizeable by creational methods taking an instance of different abstract/interface type and returning an implementation of own abstract/interface type which delegates/uses the given instance)
* None comes to mind yet. A fictive example would be new LinkedHashMap(LinkedHashSet<K>, List<V>) which returns an unmodifiable linked map which doesn't clone the items, but uses them. The java.util.Collections#newSetFromMap() and singletonXXX() methods however comes close.
Composite (recognizeable by behavioral methods taking an instance of same abstract/interface type)
* java.util.Map#putAll(Map)
* java.util.List#addAll(Collection)
* java.util.Set#addAll(Collection)
* java.nio.ByteBuffer#put(ByteBuffer) (also on CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer and DoubleBuffer)
* java.awt.Container#add(Component) (practically all over Swing thus)
Decorator (recognizeable by creational methods taking an instance of same abstract/interface type)
* All subclasses of java.io.InputStream, OutputStream, Reader and Writer have a constructor taking an instance of same type.
* Almost all implementations of java.util.List, Set and Map have a constructor taking an instance of same type.
* java.util.Collections, the checkedXXX(), synchronizedXXX() and unmodifiableXXX() methods.
* javax.servlet.http.HttpServletRequestWrapper and HttpServletResponseWrapper
Facade (recognizeable by behavioral methods which internally uses instances of different independent abstract/interface types)
* javax.faces.context.FacesContext, it internally uses among others the abstract/interface types LifeCycle, ViewHandler, NavigationHandler and many more without that the enduser has to worry about it (which are however overrideable by injection).
* javax.faces.context.ExternalContext, which internally uses ServletContext, HttpSession, HttpServletRequest, HttpServletResponse, etc.
Flyweight (recognizeable by creational methods returning a cached instance, a bit the "multiton" idea)
* java.lang.Integer#valueOf(int) (also on Boolean, Byte, Character, Short, Long, Float and Double)
Proxy (recognizeable by creational methods which returns an implementation of given abstract/interface type which in turn delegates/uses a different implementation of given abstract/interface type)
* java.lang.reflect.Proxy
* java.rmi.*, the whole API actually.
Behavioral patterns
Chain of responsibility (recognizeable by behavioral methods which (indirectly) invokes the same method in another implementation of same abstract/interface type in a queue)
* java.util.logging.Logger#log()
* javax.servlet.Filter#doFilter()
Command (recognizeable by behavioral methods in an abstract/interface type which invokes a method in an implementation of a different abstract/interface type which has been encapsulated by the command implementation during its creation)
* All implementations of java.lang.Runnable
* All implementations of javax.swing.Action
Interpreter (recognizeable by behavioral methods returning a structurally different instance/type of the given instance/type; note that parsing/formatting is not part of the pattern, determining the pattern and how to apply it is)
* java.util.Pattern
* java.text.Normalizer
* All subclasses of java.text.Format
* All subclasses of javax.el.ELResolver
Iterator (recognizeable by behavioral methods sequentially returning instances of a different type from a queue)
* All implementations of java.util.Iterator (thus among others also java.util.Scanner!).
* All implementations of java.util.Enumeration
Mediator (recognizeable by behavioral methods taking an instance of different abstract/interface type (usually using the command pattern) which delegates/uses the given instance)
* java.util.Timer (all scheduleXXX() methods)
* java.util.concurrent.Executor#execute()
* java.util.concurrent.ExecutorService (the invokeXXX() and submit() methods)
* java.util.concurrent.ScheduledExecutorService (all scheduleXXX() methods)
* java.lang.reflect.Method#invoke()
Memento (recognizeable by behavioral methods which internally changes the state of the whole instance)
* java.util.Date (the setter methods do that, Date is internally represented by a long value)
* All implementations of java.io.Serializable
* All implementations of javax.faces.component.StateHolder
Observer (or Publish/Subscribe) (recognizeable by behavioral methods which invokes a method on an instance of another abstract/interface type, depending on own state)
* java.util.Observer/java.util.Observable (rarely used in real world though)
* All implementations of java.util.EventListener (practically all over Swing thus)
* javax.servlet.http.HttpSessionBindingListener
* javax.servlet.http.HttpSessionAttributeListener
* javax.faces.event.PhaseListener
State (recognizeable by behavioral methods which changes its behaviour depending on the instance's state which can be controlled externally)
* All implementations of java.util.Iterator
* javax.faces.lifecycle.LifeCycle#execute() (controlled by FacesServlet, the behaviour is dependent on current phase (state) of JSF lifecycle)
Strategy (recognizeable by behavioral methods in an abstract/interface type which invokes a method in an implementation of a different abstract/interface type which has been passed-in as method argument into the strategy implementation)
* java.util.Comparator#compare(), executed by among others Collections#sort().
* javax.servlet.http.HttpServlet, the service() and all doXXX() methods take HttpServletRequest and HttpServletResponse and the implementor has to process them (and not to get hold of them as instance variables!).
* javax.servlet.Filter#doFilter()
Template method (recognizeable by behavioral methods which already have a "default" behaviour definied by an abstract type)
* All non-abstract methods of java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer.
* All non-abstract methods of java.util.AbstractList, java.util.AbstractSet and java.util.AbstractMap.
* javax.servlet.http.HttpServlet, all the doXXX() methods by default sends a HTTP 405 "Method Not Allowed" error to the response. You're free to implement none or any of them.
Visitor (recognizeable by two different abstract/interface types which has methods definied which takes each the other abstract/interface type; the one actually calls the method of the other and the other executes the desired strategy on it)
* javax.lang.model.element.AnnotationValue and AnnotationValueVisitor
* javax.lang.model.element.Element and ElementVisitor
* javax.lang.model.type.TypeMirror and TypeVisitor
分享到:
相关推荐
详解Java中设计模式28种方式
Java中设计模式的28种方式
Java 经典设计模式讲解以及项目实战 设计模式简介:主要介绍各种设计模式的概念和运用场景等 设计模式综合运用:主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介:主要是讲述...
java设计模式,java设计模式,java设计模式,java设计模式,java设计模式,java设计模式,java设计模式,java设计模式,
详细阐述java23中设计模式之经典应用,是很不错的东西,大家一起分享
JAVA23中设计模式疯狂Java讲义最新版本
设计模式示例代码(java)设计模式示例代码(java)v设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)...
JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式JAVA常用设计模式
总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元...
Java 23中设计模式,Java 23中设计模式Java 23中设计模式Java 23中设计模式Java 23中设计模式Java 23中设计模式Java 23中设计模式Java 23中设计模式Java 23中设计模式Java 23中设计模式
关于JAVA设计模式的试题,希望大家能用的到
java设计模式可以深入研究java程序的开发,熟悉各种开发模式,可以大大提高编程效率。
java设计模式java设计模式java设计模式java设计模式java设计模式
java设计模式,刘伟版。高清目录带书签。24种设计模式。
java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式java设计模式之工厂模式...
100多篇与设计模式学习相关的文章,涵盖了七个面向对象设计原则和24个设计模式(23个GoF设计模式 + 简单工厂模式)
java web设计模式代码
使用5种设计模式完成的一个点单系统,显示不同系列下的所有商品,点击选择冰度甜度之后添加到订单中,计算总金额,下单之后发送订单到门店的后厨制作商品。使用了抽象工厂模式、装饰模式、单例模式、代理模式、原型...
JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式JAVA设计模式
Java版本设计模式,深入浅出系列 Java版本设计模式,深入浅出系列 Java版本设计模式,深入浅出系列