java中的设计模式

官网参考：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