Java中的23种设计模式

来源：互联网发布：centos 7修改密码编辑：程序博客网时间：2024/06/06 17:00

Java中的23种设计模式：

Factory（工厂模式），    Builder（建造模式），    Factory Method（工厂方法模式），
Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
Adapter（适配器模式）， Bridge（桥梁模式），       Composite（合成模式），
Decorator（装饰模式）， Flyweight（享元模式），    Proxy（代理模式），
Command（命令模式），    Interpreter（解释器模式）， Visitor（访问者模式），
Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），
Observer（观察者模式）， State（状态模式），       Strategy（策略模式），

Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）

　　【IT168 技术】通常，一个设计模式描述了一个被证实可行的方案。这些方案非常普遍，是具有完整定义的最常用的模式。一般模式有4个基本要素：模式名称(pattern name)、问题(problem)、解决方案(solution)、效果(consequences)。

　　常见的Java设计模式有以下23种：

　　1、抽象工厂模式(Abstract Factory)：

　　提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

　　2、适配器模式(Adapter)：

　　将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口或类不兼容而不能一起工作的类可以一起工作。

　　3、桥梁模式(Bridge)：

　　将抽象部分与它的实现部分分离，使它们都可以独立地变化。

　　4、建造模式(Builder)：

　　将一个复杂对象的构建与它的表示分离，使同样的构建过程可以创建不同的表示。

　　5、责任链模式(Chain of Responsibility)：

　　为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

　　6、命令模式(Command)：

　　将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化;对请求排队或记录请求日志，以及支持可取消的操作。

　　7、合成模式(Composite)：

　　将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。

　　8、装饰模式(Decorator)：

　　动态地给一个对象添加一些额外的职责。就扩展功能而言，它能生成子类的方式更为灵活。

　　9、门面模式(Facade)：

　　为子系统中的一组接口提供一个一致的界面，门面模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

　　10、工厂方法(Factory Method)：

　　定义一个用于创建对象的接口，让子类决定将哪一个类实例化。Factory Method 使一个类的实例化延迟到其子类。

　　11、享元模式(Flyweight)：

　　运用共享技术以有效地支持大量细粒度的对象。

　　12、解释器模式(Interpreter)：

　　给定一个语言，定义它的语法的一种表示，并定义一个解释器，该解释器使用该表示解释语言中的句子。

　　13、迭代子模式(Iterator)：

　　提供一种方法顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。

　　14、调停者模式(Mediator)：

　　用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的内部表示。

　　15、备忘录模式(Memento)：

　　在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

　　16、观察者模式(Observer)：

　　定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动刷新。

　　17、原始模型模式(Prototype)：

　　用原型实例指定创建对象的种类，并且通过拷贝这个原型创建新的对象。

　　18、代理模式(Proxy)：

　　为其他对象提供一个代理以控制对这个对象的访问。

　　19、单例模式(Singleton)：

　　保证一个类仅有一个实例，并提供一个访问它的全局访问点。

　　20、状态模式(State)：

　　允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。

　　21、策略模式(Strategy)：

　　定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。

　　22、模板模式(Template Method)：

　　定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

　　23、访问者模式(Visitor)：

　　表示一个作用于某对象结构中的各元素的操作。该模式可以实现在不改变各元素的类的前提下定义作用于这些元素的新操作。

代码如下：

[java] view plaincopy
package lq.test;  
  
import java.io.*;  
import java.util.*;  
  
//*********创建型模式***************  
  
//factory method 1  
//1具体的构造算法，和2构造出的具体产品由子类实现    
interface Product {  
}  
  
//或者我也提供一个工厂的接口，由这个抽象类来继承它  
  
abstract class Factory {  
    abstract public Product fmd();;  
      
    //我认为这个方方法的存在是，是对FactoryMethod方法的补充  
    //例如可以为生成的对象赋值，计算为生成对象应付何值，前后的日值  
    //且这些都是公用的，生成产品的最主要算法还是在FactoryMethod中，  
    //这个方法只是起辅助作用，这也是一种思维方法，将具体的算法实现在一个方法中  
    //而我不直接调用此方法，而使用另外的一个方法封装它，等到了更灵活的效果，而  
    //子类需实现的内容是FactoryMethod  
    //此方法是一个TemplateMethod  
    public Product creat(); {  
        Product pd = null;  
          
        System.out.println("before operation");;  
          
        pd = fmd();;  
          
        System.out.println("end operation");;  
      
        return pd;  
    }  
}  
  
class Product1 implements Product {  
}  
  
class Factory1 extends Factory {  
    public Product fmd(); {  
        Product pd = new Product1();;  
        return pd;  
    }  
}  
  
//FactroyMethod 2  
//这种方式简单实用  
interface Producta {  
}  
  
interface Factorya {  
    Producta create();;  
}  
  
class Producta1 implements Producta {}  
  
class Factorya1 implements Factorya {  
    public Producta create(); {  
        Producta pda = null;  
        pda = new Producta1();;  
        return pda;  
    }   
}  
  
//AbstractFactory  
//AbstractFactory与FactoryMethod的不同在于AbstractFactory创建多个产品  
//感觉此模式没有什么大用  
  
//当然可以还有更多的接口  
interface Apda {}  
  
interface Apdb {}  
  
interface Afactory {  
    Apda createA();;  
    Apdb createB();;  
}  
  
class Apda1 implements Apda {}  
  
class Apdb1 implements Apdb {}  
  
//有几个接口就有几个对应的方法  
class Afactory1 implements Afactory {  
    public Apda createA(); {  
        Apda apda = null;  
        apda = new Apda1();;  
        return apda;  
    }  
      
    public Apdb createB(); {  
        Apdb apdb = null;  
        apdb = new Apdb1();;  
        return apdb;          
    }  
}  
  
//Builder  
//一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同  
//而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个TemplateMethod方法  
  
interface Cpda {}  
  
class Cpda1 implements Cpda {}  
  
interface BuilderI {  
    void buildPart1();;  
    void buildPart2();;  
      
    void initPd();;  
    Cpda getPd();;  
}  
  
abstract class BuilderA implements BuilderI {  
    Cpda cpda;  
      
    public Cpda getPd(); {  
        initPd();;  
          
        //对对象的内容进行设置  
        buildPart1();;  
        buildPart2();;  
          
        return cpda;  
    }  
}  
  
class Builder extends BuilderA {  
    public void buildPart1(); {  
        System.out.println(cpda);;  
    }  
      
    public void buildPart2(); {  
        System.out.println(cpda);;  
    }  
      
    public void initPd(); {  
        cpda = new Cpda1();;  
    }     
}  
  
//一个简单的生成产品的实现  
//1  
abstract class Fy {  
    public abstract void med1();;   
      
    static class Fy1 extends Fy {  
        public void med1(); {  
        }  
    }  
      
    public static Fy getInstance(); {  
        Fy fy = new Fy1();;  
        return fy;  
          
//      Fy fy = new Fy1(); {//这种匿名内部类是静态的！！  
//          public void med1(); {  
//          }  
//      };        
//      return fy;  
    }  
}  
  
//2  
interface Pdd {}  
  
class Pdd1 implements Pdd {}  
  
abstract class Fya {  
    public static Pdd getPd(); {  
        Pdd pdd = new Pdd1();;  
        return pdd;  
    }  
}  
  
//Prototype 在java中就是clone，又包含深拷贝和浅拷贝  
class CloneObja {  
    public CloneObja MyClone(); {  
        return new CloneObja();;  
    }  
}  
  
class CloneObjb {  
    public CloneObjb MyClone(); throws Throwable {  
        CloneObjb cobj = null;  
        cobj = (CloneObjb); pcl(this);;  
        return cobj;  
    }     
      
    //深度拷贝算法  
    private Object pcl(Object obj); throws Throwable {  
        ByteArrayOutputStream bao = new ByteArrayOutputStream(1000);;  
        ObjectOutputStream objo = new ObjectOutputStream(bao);;  
        objo.writeObject(obj);;  
          
        ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray(););;  
        ObjectInputStream obji = new ObjectInputStream(bai);;  
          
        Object objr = obji.readObject();;  
        return objr;  
    }   
}  
  
//Singleton  
//一个类只有一个对象，例如一个线程池，一个cache  
class Singleton1 {  
    public static Singleton1 instance = new Singleton1();;    
      
    private Singleton1(); {       
    }  
      
    public static Singleton1 getInstance(); {  
        return instance;  
    }  
}  
  
class Singleton2 {  
    public static Singleton2 instance;  
      
    private Singleton2(); {  
    }  
      
//  public static Singleton2 getInstance(); {         
//      if (instance == null); {  
//          instance = new Singleton2();;  
//      }  
//        
//      return instance;  
//  }  
      
    public static Singleton2 getInstance(); {  
        synchronized(Singleton2.class); {  
            if (instance == null); {  
                instance = new Singleton2();;  
            }  
        }  
          
        return instance;  
    }  
}  
  
//**********结构型模式**********  
  
//Adapter  
//基本方法有两种，一种是使用引用一种使用继承  
//将不符合标准的接口转成符合标准的接口，接口的修改主要是参数的增减，  
//返回值类型,当然还有方法名  
//感觉这就是封装的另一种表示形式，封装有用方法封装(在方法中调用功能方法);，  
//用类封装(先传入功能方法所在的类的对象，通过调用此对象的功能方法);  
  
//使用引用的形式  
class Adapteea {  
    public void kk(); {}  
}  
  
interface Targeta {  
    String vv(int i, int k);;  
}  
  
class Adaptera implements Targeta{  
    Adapteea ade;  
      
    public Adaptera(Adapteea ade); {  
        this.ade = ade;  
    }  
      
    public String vv(int i, int k); {  
        //具体的业务方法实现在Adaptee中，这个方法  
        //只起到了接口转换的作用  
        //调用此方法是通过引用  
        ade.kk();;  
        return null;  
    }  
}  
  
//使用继承形式的  
class Adapteeb {  
    public void kk(); {}  
}  
  
interface Targetb {  
    String vv(int i, int k);;  
}  
  
class Adapterb extends Adapteeb implements Targetb {  
    public String vv(int i, int k); {  
        //调用此方法是通过继承  
        kk();;  
        return null;  
    }  
}  
  
//Proxy  
interface Subject {  
    void request();;  
}   
  
class realSubject implements Subject {  
    public void request(); {          
        //do the real business  
    }  
}  
  
class Proxy implements Subject {  
    Subject subject;  
      
    public Proxy(Subject subject); {  
        this.subject = subject;  
    }  
      
    public void request(); {  
        System.out.println("do something");;  
          
        subject.request();;  
          
        System.out.println("do something");;  
    }  
}  
  
//Bridge  
//感觉就是多态的实现  
  
interface Imp {  
    void operation();;  
}  
  
class Cimp1 implements Imp {  
    public void operation(); {  
        System.out.println("1");;  
    }  
}  
  
class Cimp2 implements Imp {  
    public void operation(); {  
        System.out.println("2");;  
    }  
}  
  
class Invoker {  
    Imp imp = new Cimp1();;  
      
    public void invoke(); {  
        imp.operation();;  
    }  
}  
  
//Composite  
  
interface Component {  
    void operation();;  
      
    void add(Component component);;  
      
    void remove(Component component);;  
}  
  
class Leaf implements Component {  
    public void operation(); {  
        System.out.println("an operation");;  
    }  
      
    public void add(Component component); {  
        throw new UnsupportedOperationException();;  
    }  
      
    public void remove(Component component); {  
        throw new UnsupportedOperationException();;  
    }  
}  
  
class Composite implements Component {  
    List components = new ArrayList();;  
      
    public void operation(); {  
        Component component = null;  
          
        Iterator it = components.iterator();;         
        while (it.hasNext();); {  
            //不知道此component对象是leaf还是composite，  
            //如果是leaf则直接实现操作，如果是composite则继续递归调用  
            component = (Component); it.next();;  
            component.operation();;  
        }  
    }  
      
    public void add(Component component); {       
        components.add(component);;  
    }  
      
    public void remove(Component component); {        
        components.remove(component);;  
    }  
}  
  
//Decorator  
//对一个类的功能进行扩展时，我可以使用继承，但是不够灵活，所以选用了  
//另外的一种形式,引用与继承都可活得对对象的一定的使用能力，而使用引用将更灵活  
//我们要保证是对原功能的追加而不是修改，否则只能重写方法，或使用新的方法  
//注意concrete的可以直接new出来，  
//而decorator的则需要用一个另外的decorator对象才能生成对象  
//使用对象封装，和公用接口  
//Decorator链上可以有多个元素  
  
interface Componenta {  
    void operation();;  
}  
  
class ConcreteComponent implements Componenta {  
    public void operation(); {  
        System.out.println("do something");;  
    }  
}  
  
class Decorator implements Componenta {  
    private Componenta component;  
      
    public Decorator(Componenta component); {  
        this.component = component;  
    }  
      
    public void operation(); {  
        //do something before  
          
        component.operation();;  
          
        //do something after  
    }  
}  
  
//Facade  
//非常实用的一种设计模式，我可以为外部提供感兴趣的接口  
  
class Obj1 {  
    public void ope1(); {}  
    public void ope2(); {}  
}  
  
class Obj2 {  
    public void ope1(); {}  
    public void ope2(); {}  
}  
  
class Facade {  
    //我得到了一个简洁清晰的接口  
    public void fdMethod(); {  
        Obj1 obj1 = new Obj1();;  
        Obj2 obj2 = new Obj2();;  
          
        obj1.ope1();;  
        obj2.ope2();;  
    }  
}  
  
//Flyweight  
//空  
  
//**********行为型模式*************  
  
//Chain of Responsibility  
//与Decorator的实现形式相类似，  
//Decorator是在原来的方法之上进行添加功能，而  
//Chain则是判断信号如果不是当前处理的则转交个下一个节点处理  
//我可以使用if分支来实现相同的效果，但是不够灵活，链上的每个节点是可以替换增加的，相对  
//比较灵活，我们可以设计接口实现对节点的增删操作，而实现更方便的效果  
//这个是一个链状的结构，有没有想过使用环状结构  
  
interface Handler {  
    void handRequest(int signal);;  
}  
  
class CHandler1 implements Handler {  
    private Handler handler;  
      
    public CHandler1(Handler handler); {  
        this.handler = handler;  
    }  
      
    public void handRequest(int signal); {  
        if (signal == 1); {  
            System.out.println("handle signal 1");;  
        }  
        else {  
            handler.handRequest(signal);;  
        }  
    }   
}  
  
class CHandler2 implements Handler {  
    private Handler handler;  
      
    public CHandler2(Handler handler); {  
        this.handler = handler;  
    }  
      
    public void handRequest(int signal); {  
        if (signal == 2); {  
            System.out.println("handle signal 2");;  
        }  
        else {  
            handler.handRequest(signal);;  
        }  
    }   
}  
  
class CHandler3 implements Handler {  
    public void handRequest(int signal); {  
        if (signal == 3); {  
            System.out.println("handle signal 3");;  
        }  
        else {  
            throw new Error("can't handle signal");;  
        }  
    }   
}  
  
class ChainClient {  
    public static void main(String[] args); {  
        Handler h3 = new CHandler3();;  
        Handler h2 = new CHandler2(h3);;  
        Handler h1 = new CHandler1(h2);;  
          
        h1.handRequest(2);;  
    }  
}  
  
//Interpreter  
//感觉跟Composite很类似，只不过他分文终结符和非终结符  
  
//Template Method  
  
abstract class TemplateMethod {  
    abstract void amd1();;  
      
    abstract void amd2();;  
      
    //此方法为一个Template Method方法  
    public void tmd(); {  
        amd1();;  
        amd2();;  
    }  
}  
  
//State  
  
//标准型  
//状态和操作不应该耦合在一起  
class Contexta {  
    private State st;  
      
    public Contexta(int nst); {  
        changeStfromNum(nst);;  
    }  
      
    public void changeStfromNum(int nst); {  
        if (nst == 1); {  
            st = new CStatea1();;  
        }  
        else if (nst == 2); {  
            st = new CStatea2();;  
        }  
          
        throw new Error("bad state");;  
    }  
      
    void request(); {  
        st.handle(this);;  
    }  
}  
  
interface State {  
    void handle(Contexta context);;  
}  
  
class CStatea1 implements State {  
    public void handle(Contexta context); {  
        System.out.println("state 1");;  
        //也许在一个状态的处理过程中要改变状态，例如打开之后立即关闭这种效果  
        //context.changeStfromNum(2);;  
    }  
}  
  
class CStatea2 implements State {  
    public void handle(Contexta context); {  
        System.out.println("state 2");;  
    }  
}  
  
//工厂型  
//根据状态不通生成不同的state  
  
//class StateFactory {  
//  public static State getStateInstance(int num); {  
//      State st = null;  
//        
//      if (num == 1); {  
//          st = new CStatea1();;  
//      }  
//      else if (num == 2); {  
//          st = new CStatea2();;  
//      }  
//        
//      return st;  
//  }  
//}  
  
//Strategy  
//跟Bridge相类似，就是一种多态的表示  
  
//Visitor  
//双向引用，使用另外的一个类调用自己的方法,访问自己的数据结构  
interface Visitor {   
    void visitElement(Elementd element);;  
}  
  
class CVisitor implements Visitor {  
    public void visitElement(Elementd element); {  
        element.operation();;  
    }  
}  
  
interface Elementd {      
    void accept(Visitor visitor);;  
      
    void operation();;  
}  
  
class CElementd implements Elementd {  
    public void accept(Visitor visitor); {  
        visitor.visitElement(this);;  
    }  
      
    public void operation(); {  
        //实际的操作在这里  
    }  
}  
  
class Clientd {  
    public static void main(); {  
        Elementd elm = new CElementd();;  
        Visitor vis = new CVisitor();;  
          
        vis.visitElement(elm);;  
    }  
}  
  
//Iteraotr  
//使用迭代器对一个类的数据结构进行顺序迭代  
  
interface Structure {  
    interface Iteratora {  
        void first();;  
          
        boolean hasElement();;  
          
        Object next();;  
          
    }  
}  
  
class Structure1 implements Structure {  
    Object[] objs = new Object[100];  
      
    //使用内部类是为了对Struture1的数据结构有完全的访问权  
    class Iteratora1 implements Iteratora {  
        int index = 0;  
          
        public void first(); {  
            index = 0;  
        }  
          
        public boolean hasElement(); {  
            return index < 100;  
        }   
          
        public Object next(); {  
            Object obj = null;  
              
            if (hasElement();); {  
                obj = objs[index];  
                index++;  
            }  
              
            return obj;  
        }  
    }  
}  
  
//Meditor  
  
class A1 {  
    public void operation1(); {}  
    public void operation2(); {}  
}  
  
class A2 {  
    public void operation1(); {}  
    public void operation2(); {}  
}  
  
class Mediator {  
    A1 a1;  
    A2 a2;  
      
    public Mediator(A1 a1, A2 a2); {  
        this.a1 = a1;  
        this.a2 = a2;  
          
    }  
      
    //如果我想实现这个功能我可能会把他放在A1中  
    //但是这样耦合大，我不想在A1中出现A2对象的引用，  
    //所以我使用了Mediator作为中介  
    public void mmed1(); {  
        a1.operation1();;  
        a2.operation2();;  
    }  
      
    public void mmed2(); {  
        a2.operation1();;  
        a1.operation2();;  
    }  
}  
  
//Command  
//我认为就是将方法转换成了类  
  
class Receiver {  
    public void action1(); {}  
      
    public void action2(); {}  
}  
  
interface Command {  
    void Execute();;  
}  
  
class CCommand1 implements Command {  
    private Receiver receiver;  
      
    public CCommand1(Receiver receiver); {  
        this.receiver = receiver;  
    }  
      
    public void Execute(); {  
        receiver.action1();;  
    }  
}  
  
class CCommand2 implements Command {  
    private Receiver receiver;  
      
    public CCommand2(Receiver receiver); {  
        this.receiver = receiver;  
    }  
      
    public void Execute(); {  
        receiver.action2();;  
    }  
}  
  
//Observer  
//在这里看似乎这个模式没有什么用  
//但是如果我有一个线程监控Subject，如果Subject的状态  
//发生了变化，则更改Observer的状态，并出发一些操作，这样就有实际的意义了  
//Observer与Visitor有相似的地方，都存在双向引用  
//Subject可以注册很多Observer  
  
interface Subjectb {  
    void attach(Observer observer);;  
      
    void detach(Observer observer);;  
      
    void mynotify();;  
      
    int getState();;  
      
    void setState(int state);;  
}  
  
class Subjectb1 implements Subjectb {  
    List observers = new ArrayList();;  
    int state;  
      
    public void attach(Observer observer); {  
        observers.add(observer);;  
    }  
      
    public void detach(Observer observer); {  
        observers.remove(observer);;  
    }  
      
    public void mynotify(); {  
        Observer observer = null;  
        Iterator it = observers.iterator();;  
          
        while (it.hasNext();); {  
            observer = (Observer); it.next();;  
            observer.Update();;  
        }  
    }  
  
    public int getState(); {  
        return state;  
    }  
  
    public void setState(int state); {  
        this.state = state;  
    }  
}  
  
interface Observer {  
    void Update();;  
}  
  
class Observer1 implements Observer {  
    Subjectb subject;  
    int state;  
      
    public Observer1(Subjectb subject); {  
        this.subject = subject;  
    }  
      
    public void Update(); {       
        this.state = subject.getState();;  
    }  
      
    public void operation(); {  
        //一些基于state的操作  
    }  
}  
  
//Memento  
//感觉此模式没有什么大用  
  
class Memento {  
    int state;  
  
    public int getState(); {  
        return state;  
    }  
  
    public void setState(int state); {  
        this.state = state;  
    }  
}  
  
class Originator {  
    int state;  
      
    public void setMemento(Memento memento); {  
        state = memento.getState();;  
    }  
      
    public Memento createMemento(); {  
        Memento memento = new Memento();;  
        memento.setState(1);;  
        return memento;  
    }  
  
    public int getState(); {  
        return state;  
    }  
  
    public void setState(int state); {  
        this.state = state;  
    }  
}  
  
class careTaker {  
    Memento memento;  
      
    public void saverMemento(Memento memento); {  
        this.memento = memento;  
    }  
      
    public Memento retrieveMemento(); {  
        return memento;  
    }  
}  
  
//程序最终还是顺序执行的，是由不通部分的操作拼接起来的  
//将不同类的代码拼接起来是通过引用实现的，有了引用我就  
//相当于有了一定访问数据结构和方法的能力，这与写在类内部  
//差不多，例如我想将一个类中的一个方法抽离出去，因为这个方法依赖与此类的数据和其他方法  
//直接将代码移走是不行的，但如果我们拥有了此类对象的引用，则与写在此类  
//内部无异，所以我们拥有了引用就可以将此方法移出  
public class tt1 {  
    public static void main(String[] args); {  
    }  
}  

常用的九种模式：

　　1 Factory Pattern（工厂模式）

　　上榜理由：将程序中创建对象的操作，单独出来处理，大大提高了系统扩展的柔性，接口的抽象化处理给相互依赖的对象创建提供了最好的抽象模式。

　　2 Facade Pattern

　　上榜理由：将表现层和逻辑层隔离，封装底层的复杂处理，为用户提供简单的接口，这样的例子随处可见。门面模式很多时候更是一种系统架构的设计，在我所做的项目中，就实现了门面模式的接口，为复杂系统的解耦提供了最好的解决方案。

　　3 Command Pattern

　　上榜理由：将请求封装为对象，从而将命令的执行和责任分开。通常在队列中等待命令，这和现实多么的相似呀。如果你喜欢发号施令，请考虑你的ICommond吧。

　　4 Strategy Pattern

　　上榜理由：策略模式，将易于变化的部分封装为接口，通常Strategy 封装一些运算法则，使之能互换。Bruce Zhang在他的博客中提到策略模式其实是一种“面向接口”的编程方法，真是恰如其分。

　　5 Iterator Pattern

　　上榜理由：相信任何的系统中，都会用到数组、集合、链表、队列这样的类型吧，那么你就不得不关心迭代模式的来龙去脉。在遍历算法中，迭代模式提供了遍历的顺序访问容器，GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。.NET中就是使用了迭代器来创建用于foreach的集合。

　　6 Adapter Pattern

　　上榜理由：在原类型不做任何改变的情况下，扩展了新的接口，灵活且多样的适配一切旧俗。这种打破旧框框，适配新格局的思想，是面向对象的精髓。以继承方式实现的类的Adapter模式和以聚合方式实现的对象的Adapter模式，各有千秋，各取所长。看来，把它叫做包装器一点也不为过，

　　7 Observer Pattern

　　上榜理由：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。观察者和被观察者的分开，为模块划分提供了清晰的界限。在.NET中使用委托和事件可以更好的实现观察者模式，事件的注册和撤销不就对应着观察者对其对象的观察吗？

　　8 Bridge Pattern

　　上榜理由：把实现和逻辑分开，对于我们深刻理解面向对象的聚合复用的思想甚有助益。

　　9 Singleton Pattern(单例模式)

　　上榜理由：改善全局变量和命名空间的冲突，可以说是一种改良了的全局变量。这种一个类只有一个实例，且提供一个访问全局点的方式，更加灵活的保证了实例的创建和访问约束。