设计模式概述
?
?
?
设计模式主要分三个类型:创建型、结构型和行为型。
其中创建型有：
??? 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点
??? 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
??? 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
??? 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
??? 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
行为型有：
??? 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
??? 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
??? 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
??? 九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
??? 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。
??? 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
??? 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系
??? 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
??? 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。
??? 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
??? 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
?
结构型有：
??? 十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。
??? 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。
??? 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问
??? 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
??? 二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。
??? 二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。
??? 二十三、Flyweight，享元模式
?? 23种设计模式要在这里详细的都说一遍内容实在太多了啊，推荐你一本好书《软件秘笈：设计模式那点事》，里面讲解的23中设计模式例子很生动，容易理解，还有JDK中设计模式应用情况，看了收获挺大的！百度里面搜“设计模式”，第一条中设计模式百度百科中就有首推该图书，浏览量在20几万以上的，不会错的。
?
酷壳版主陈皓近日发表博文《JDK里的设计模式》，文中他列出了JDK中有关23个经典设计模式的示例。现把全文转载于此，全文如下：
下面是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:
为一个对象动态的加上一系列的动作，而不需要因为这些动作的不同而产生大量的继承类。这个模式在JDK中几乎无处不在，所以，下面的列表只是一些典型的。
● 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
Null Object:
这个模式用来解决如果一个Collection中没有元素的情况。
● java.util.Collections#emptyList()
● java.util.Collections#emptyMap()
● java.util.Collections#emptySet()
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
在stakeoverflow也有相应的讨论：
http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns
原文链接：http://coolshell.cn/articles/3320.html
?
???????设计模式的几大原则：?????? 单一职责原则：就一个类而言，应该仅有一个引起它变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到竟想不到的破坏。?
合成/聚合复用原则：尽量使用合成/聚合，尽量不要使用类继承。优先使用对象的合成/聚合将有助于你保持每个类被封装，并被集中在单个任务上，这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物。
