设计模式（创建型）

 设计模式 --创建型

范围\目的	创建型模式	结构型模式	行为型模式
类模式	工厂方法模式	（类）适配器模式	解释器模式 模板方法模式
对象模式	抽象工厂模式 建造者模式 原型模式 单例模式	（对象）适配器模式 桥接模式 组合模式 装饰模式 外观模式 享元模式 代理模式	职责链模式 命令模式 迭代器模式 中介者模式 备忘录模式 观察者模式 状态模式 策略模式 访问者模式

 

 

 

 

 

 

 

 

 

 

 

 

 

　　根据目的、用途的不同，分为创建性模式、结构性模式、行为性模式。创建型模式主要用于创建对象，结构型模式主要用于处理类和对象的组合，行为性模式主要用于描述类或对象的交互以及职责分配。

　　根据处理范围不同，设计模式又可分为类模式和对象模式，类模式处理类与子类的关系，通过处理这些关系来建立继承，属于静态关系，在编译时候确定下来；对象模式处理对象之间的关系，运行时发生变化，属于动态关系。

 1. 创建性模式Creational（5种）

一．抽象工厂模式（对象型）

模式动机

a)        当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

b)        抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。

c)        抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。

 

抽象工厂模式是所有工厂模式中最为抽象，最为一般性的模式

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

说明：抽象工厂方法引入了产品的等级结构和产品族的概念，产品的等级结构指抽象的产品与具体的产品所构成的继承层次关系；产品族指的是同一个工厂所生产的一系列产品，也就是位于不同产品等级结构且功能相关联的产品所组成的家族。

 

　　抽象工厂模式包含如下角色：

　　　　AbstractFactory：抽象工厂

　　　　ConcreteFactory：具体工厂

　　　　AbstractProduct：抽象产品

　　　　Product：具体产品

　　抽象工厂模式的优点

　　抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。

　　 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。

　　增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

抽象工厂模式的缺点

　　在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。

　　开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）

在以下情况下可以使用抽象工厂模式：

• 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
• 系统中有多于一个的产品族，而每次只使用其中某一产品族。
• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
• 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

 

二．工厂模式（类）

　　当抽象工厂退化为只有一个产品的等级结构时，就会变成工厂方法模式，整个工厂只生产一种产品，工厂方法模式是类创建模式，又叫虚拟构造器。父类是负责定义创建对象的公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化延迟到子类来进行。

定义：定义一个创建对象的接口，但由子类决定需要实例化哪个类，工厂方法使得子类实例化的过程推迟。

　　工厂方法模式的优点

　　 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。

　　基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。

　　使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。

　　工厂方法模式的缺点

　　在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。

　　由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

　　在以下情况下可以使用工厂方法模式：

　　一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。

　　一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

　　将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

三．建造者模式（对象型）

　　动机

　　在软件开发中，也存在大量类似汽车一样的复杂对象，它们拥有一系列成员属性，这些成员属性中有些是引用类型的成员对象。而且在这些复杂对象中，还可能存在一些限制条件，如某些属性没有赋值则复杂对象不能作为一个完整的产品使用；有些属性的赋值必须按照某个顺序，一个属性没有赋值之前，另一个属性可能无法赋值等。

　　复杂对象相当于一辆有待建造的汽车，而对象的属性相当于汽车的部件，建造产品的过程就相当于组合部件的过程。由于组合部件的过程很复杂，因此，这些部件的组合过程往往被“外部化”到一个称作建造者的对象里，建造者返还给客户端的是一个已经建造完毕的完整产品对象，而用户无须关心该对象所包含的属性以及它们的组装方式，这就是建造者模式的模式动机。

 　　定义：强调的是将一个复杂的对象的表示与其构造相分离，使得同样的构建过程能够得出不同的表示。

　　说明：建造者模式是一步一步地创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建他们，而无需知道具体的构建细节。

 

 

　　建造者模式包含如下角色：

　　Builder：抽象建造者

　　ConcreteBuilder：具体建造者

　　 Director：指挥者

　　Product：产品角色

　　建造者模式的结构中还引入了一个指挥者类Director，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。

public class Director
{
  private Builder builder;

  public Director(Builder builder)
  {

         this.builder=builder;
  }

   public void setBuilder(Builder builder)
  {
         this.builder=builer;
  }

  public Product construct()
  {
         builder.buildPartA();
         builder.buildPartB();
         builder.buildPartC();
         return builder.getResult();
  }
}

 

　　 建造者模式的优点

　　在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

　　 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

　　可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

　　增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

　　 建造者模式的缺点如下：

　　建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

　　如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

　　模式适用环境

　　在以下情况下可以使用建造者模式：

• 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
• 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
• 对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中。
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

 四．原型模式（对象型）

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

　　说明：有些对象是需要频繁创建的，用原型实例指定创建对象的类型，并且通过拷贝这个原型来创建新的同类型的对象，分为浅克隆和深克隆，浅克隆只复制拷贝的对象，不复制引用的对象，即成员对象不复制；深克隆，引用也同样复制。

在以下情况下可以使用原型模式：

　　创建新对象成本较大，新的对象可以通过原型模式对已有对象进行复制来获得，如果是相似对象，则可以对其属性稍作修改。

　　如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占内存不大的时候，也可以使用原型模式配合备忘录模式来应用。相反，如果对象的状态变化很大，或者对象占用的内存很大，那么采用状态模式会比原型模式更好。

　　需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。

五．单例模式（对象型）

　　模式动机

　　a)        如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。

　　b)        一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

 

　　定义：保证某一个类只有一个实例，并提供一个访问它的全局访问点

　　单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式

 

　　饿汉式单例与懒汉式单例类比较

　　饿汉式单例类在自己被加载时就将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，则比懒汉式单例类稍好些。

　　 懒汉式单例类在实例化时，必须处理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的机率变得较大，需要通过同步化机制进行控制。

 

2.结构性设计模式Structural（7种）

　　结构型模式所描述的是如何将类和对象结合在一起来形成一个更大的结构，它描述两种不同的事物：类和对象，根据这一点，可分为类结构型和对象结构型模式。类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系；对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法。根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式

一． 适配器模式（对象型和类型）

模式动机

a)        在软件开发中采用类似于电源适配器的设计和编码技巧被称为适配器模式。

b)        通常情况下，客户端可以通过目标类的接口访问它所提供的服务。有时，现有的类可以满足客户类的功能需要，但是它所提供的接口不一定是客户类所期望的，这可能是因为现有类中方法名与目标类中定义的方法名不一致等原因所导致的。

c)        在这种情况下，现有的接口需要转化为客户类期望的接口，这样保证了对现有类的重用。如果不进行这样的转化，客户类就不能利用现有类所提供的功能，适配器模式可以完成这样的转化。

d)       在适配器模式中可以定义一个包装类，包装不兼容接口的对象，这个包装类指的就是适配器(Adapter)，它所包装的对象就是适配者(Adaptee)，即被适配的类。

e)        适配器提供客户类需要的接口，适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用。也就是说：当客户类调用适配器的方法时，在适配器类的内部将调用适配者类的方法，而这个过程对客户类是透明的，客户类并不直接访问适配者类。因此，适配器可以使由于接口不兼容而不能交互的类可以一起工作。这就是适配器模式的模式动机。

 

定义：将一个接口转换成客户希望的另一个接口，从而使接口不兼容的那些类可以在一起工作。

说明：适配器模式既可作为类结构模式，也可作为对象结构模式，类适配模式是通过一个具体的类，将适配者适配到目标接口当中；对象适配模式是指一个适配器可以将多个不同的适配者适配到同一目标

类适配器模式：

public class Adapter extends Adaptee implements Target

{

       public void request()

       {

              specificRequest();

       }

}

 

public class Adapter extends Target

{

       private Adaptee adaptee;

      

       public Adapter(Adaptee adaptee)

       {

              this.adaptee=adaptee;

       }

      

       public void request()

       {

              adaptee.specificRequest();

       }

}

 

适配器模式包含如下角色：

ü  Target：目标抽象类

ü  Adapter：适配器类

ü  Adaptee：适配者类

ü  Client：客户类

适配器模式的优点

ü  将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。

ü  增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。

ü  灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。

类适配器模式还具有如下优点：

ü  由于适配器类是适配者类的子类，因此可以在适配器类中置换一些适配者的方法，使得适配器的灵活性更强。

类适配器模式的缺点如下：

ü  对于Java、C#等不支持多重继承的语言，一次最多只能适配一个适配者类，而且目标抽象类只能为抽象类，不能为具体类，其使用有一定的局限性，不能将一个适配者类和它的子类都适配到目标接口。

在以下情况下可以使用适配器模式：

ü  系统需要使用现有的类，而这些类的接口不符合系统的需要。

ü  想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。

 

一．              桥接模式（对象型模式）

将抽象部分和实现部分分离，使它们都可以独立地发生变化，桥接模式是一种对象的结构模式，桥接模式类似于多重继承方案，但是多重继承方案往往违背了类的单一职责原则，并且复用性较差，桥接模式相对于多重继承来说，是更好的解决方案，桥接模式既能达到多重继承的用途，又能有利于复用。

模式动机

w  设想如果要绘制矩形、圆形、椭圆、正方形，我们至少需要4个形状类，但是如果绘制的图形需要具有不同的颜色，如红色、绿色、蓝色等，此时至少有如下两种设计方案：

w  第一种设计方案是为每一种形状都提供一套各种颜色的版本。

w  第二种设计方案是根据实际需要对形状和颜色进行组合。

w  对于有两个变化维度（即两个变化的原因）的系统，采用方案二来进行设计系统中类的个数更少，且系统扩展更为方便。设计方案二即是桥接模式的应用。桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量

 

 

 

定义：将抽象部分和实现部分分离，使它们都可以独立地发生变化

 

桥接模式包含如下角色：

Abstraction：抽象类

RefinedAbstraction：扩充抽象类

Implementor：实现类接口

ConcreteImplementor：具体实现类

理解桥接模式，重点需要理解如何将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化。

ü  抽象化：抽象化就是忽略一些信息，把不同的实体当作同样的实体对待。在面向对象中，将对象的共同性质抽取出来形成类的过程即为抽象化的过程。

ü  实现化：针对抽象化给出的具体实现，就是实现化，抽象化与实现化是一对互逆的概念，实现化产生的对象比抽象化更具体，是对抽象化事物的进一步具体化的产物。

ü  脱耦：脱耦就是将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联，将两个角色之间的继承关系改为关联关系。桥接模式中的所谓脱耦，就是指在一个软件系统的抽象化和实现化之间使用关联关系（组合或者聚合关系）而不是继承关系，从而使两者可以相对独立地变化，这就是桥接模式的用意。

在以下情况下可以使用桥接模式：

ü  如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。

ü  抽象化角色和实现化角色可以以继承的方式独立扩展而互不影响，在程序运行时可以动态将一个抽象化子类的对象和一个实现化子类的对象进行组合，即系统需要对抽象化角色和实现化角色进行动态耦合。

ü  一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。

ü  虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。

ü  对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。

 

一．              组合模式（对象型模式），也称为整体-部分模式

是一种整体和部分的结构，通过组合多个对象形成树形结构，用这种方式表示整体和部分的结构层次。在组合模式中，对单个对象和组合对象的使用具有一致性。

定义：将对象组合成树形结构以表示整体和部分的层次结构，使得用户对单个对象和组合对象的使用具有一致性

ü  组合模式包含如下角色：

• Component: 抽象构件
• Leaf: 叶子构件
• Composite: 容器构件
• Client: 客户类

ü  在以下情况下可以使用组合模式：

• 需要表示一个对象整体或部分层次，在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，可以一致地对待它们。
• 让客户能够忽略不同对象层次的变化，客户端可以针对抽象构件编程，无须关心对象层次结构的细节。
• 对象的结构是动态的并且复杂程度不一样，但客户需要一致地处理它们。

 

一．              装饰模式（对象模式）

一般有两种方式可以实现给一个类或对象增加行为：

a)        继承机制，使用继承机制是给现有类添加功能的一种有效途径，通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法。但是这种方法是静态的，用户不能控制增加行为的方式和时机。

b)        关联机制，即将一个类的对象嵌入另一个对象中，由另一个对象来决定是否调用嵌入对象的行为以便扩展自己的行为，我们称这个嵌入的对象为装饰器(Decorator)。

 

它可以动态地对一个对象增加一些额外的职责，就增加对象功能来说，比生成子类更加灵活一些，为类增加职责就是定义类的功能，为达到这个目的，可以增加子类的方法来实现，但是装饰模式也可以做到，而且更加灵活。

定义：动态地对一个对象增加额外的职责。它提供了用子类扩展功能的一个灵活的替代，比派生一个子类更加灵活。

当需要为对象动态的添加一些功能，并且可以动态的撤销或是不能使用子类展功能的时候，这两种情况时可以使用装饰模式

 

 

ü  装饰模式包含如下角色：

• Component: 抽象构件
• ConcreteComponent: 具体构件
• Decorator: 抽象装饰类
• ConcreteDecorator: 具体装饰类

ü  在以下情况下可以使用装饰模式：

ü  在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

ü  需要动态地给一个对象增加功能，这些功能也可以动态地被撤销。 

ü  当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。不能采用继承的情况主要有两类：第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；第二类是因为类定义不能继承（如final类）。

典型的抽象装饰类代码：

 

public class Decorator extends Component

{

private Component component;

public Decorator(Component component)

{

        this.component=component;

}

public void operation()

{

        component.operation();

}

}

典型的具体装饰类代码：

public class ConcreteDecorator extends Decorator

{

       public ConcreteDecorator(Component component)

       {

              super(component);

       }

       public void operation()

       {

              super.operation();

              addedBehavior();

       }

       public void addedBehavior()

       {

                  //新增方法 

        }

} 

 

一．              外观模式（对象结构模式）

定义：定义一个高层接口，为子系统中的一组接口提供一个一致的外观，从而简化了该子系统的使用

 

ü  外观模式包含如下角色：

ü  Facade: 外观角色

ü  SubSystem:子系统角色

ü  典型的外观角色代码：

public class Facade

{

    private SubSystemA obj1 = new SubSystemA();

    private SubSystemB obj2 = new SubSystemB();

    private SubSystemC obj3 = new SubSystemC();

    public void method()

    {

        obj1.method();

        obj2.method();

        obj3.method();

    }

}

ü  在以下情况下可以使用外观模式：

ü  当要为一个复杂子系统提供一个简单接口时可以使用外观模式。该接口可以满足大多数用户的需求，而且用户也可以越过外观类直接访问子系统。

ü  客户程序与多个子系统之间存在很大的依赖性。引入外观类将子系统与客户以及其他子系统解耦，可以提高子系统的独立性和可移植性。

ü  在层次化结构中，可以使用外观模式定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，降低层之间的耦合度。

ü  不要试图通过外观类为子系统增加新行为

ü  不要通过继承一个外观类在子系统中加入新的行为，这种做法是错误的。外观模式的用意是为子系统提供一个集中化和简化的沟通渠道，而不是向子系统加入新的行为，新的行为的增加应该通过修改原有子系统类或增加新的子系统类来实现，不能通过外观类来实现。

ü  外观模式与迪米特法则

ü  外观模式创造出一个外观对象，将客户端所涉及的属于一个子系统的协作伙伴的数量减到最少，使得客户端与子系统内部的对象的相互作用被外观对象所取代。外观类充当了客户类与子系统类之间的“第三者”，降低了客户类与子系统类之间的耦合度，外观模式就是实现代码重构以便达到“迪米特法则”要求的一个强有力的武器。

 

一．              享元模式（对象型模式）

定义：提供支持大量细粒度对象共享的有效方法

通过运用共享技术，有效地自制细粒度的对象，系统只使用少量的对象，而这些对象都很类似，状态变化很小，对象使用次数增多。享元对象可以做到共享的关键，是能区分出内部状态和外部状态。内部状态是存储在享元对象的内部，并且不会随时间和环境而发生变化，内部状态是可以共享的。外部状态是随着外部环境的改变而改变的，不可以共享，所以外部状态必须由客户端保存，并且在享元对象被创建之后，在需要使用的时候，传递到享元对象的内部，外部状态之间是相互独立的。

 

一．              代理模式（对象型模式）

模式动机

a)        在某些情况下，一个客户不想或者不能直接引用一个对象，此时可以通过一个称之为“代理”的第三者来实现间接引用。代理对象可以在客户端和目标对象之间起到中介的作用，并且可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。

 

定义：为其他对象提供一种代理，由代理对象控制这个对象的访问

协调调用者和被调用者，减低耦合度

缺点是请求速度变慢，而且增加了额外的工作量

 

 

ü  代理模式包含如下角色：

• Subject: 抽象主题角色
• Proxy: 代理主题角色
• RealSubject: 真实主题角色

ü  根据代理模式的使用目的，常见的代理模式有以下几种类型：

ü  远程(Remote)代理：为一个位于不同的地址空间的对象提供一个本地的代理对象，这个不同的地址空间可以是在同一台主机中，也可是在另一台主机中，远程代理又叫做大使(Ambassador)。

ü  虚拟(Virtual)代理：如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。

Copy-on-Write代理：它是虚拟代理的一种，把复制（克隆）操作延迟到只有在客户端真正需要时才执行。一般来说，对象的深克隆是一个开销较大的操作，Copy-on-Write代理可以让这个操作延迟，只有对象被用到的时候才被克隆。