本文是《设计模式——可复用面对对象软件的基础》的笔记。

面对对象设计的几个原则：
1.针对接口编程，而不是针对实现编程
2.优先使用对象组合，而不是类继承
类继承是在编译时刻静态定义的，可以直接使用，但无法在运行时刻改变从父类继承的实现，并且父类的变化会引起子类的变化。所以类继承最好是只继承抽象类。
对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。并且，优先使用对象组合有助于保持每个类被封装，并被集中在单个任务上。

1.创建型模式
创建性模式抽象了实例化过程。第一，它们都将关于该系统使用哪些具体的类的信息封装起来。第二，它们隐藏了这些类的实例是如何被创建和放在一起的。
1.1 抽象工厂模式（abstract factory）
提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。
适用范围：
1.一个系统要独立于它的产品的创建、组合和表示时
2.一个系统要由多个产品系列中的一个来配置时
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时
4.当你提供一个产品类库，而只想显示它们的接口而不是实现时
实现：
AbstractFactory：声明一个创建抽象产品对象的操作接口。
ConcreteFactory：实现创建具体产品对象的操作。
AbstractProduct：为一类产品对象声明一个接口。
ConcreteProduct：定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口
通常在运行时刻创建一个ConcreteFactory类的实例。AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。
（抽象工厂为父类，子类为具体的工厂，调用不同子类产生不同的产品。）

1.2 生成器模式（builder）
将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同表示。
适用范围：
1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时
2.当构造过程必须允许被构造的对象有不同的表示时
实现：
Builder：定义创建一个Product对象各个部件的抽象接口
ConcreteBuilder：实现Builder的接口并提供获取Product的接口
Director：构造一个使用Builder接口的对象
Product：表示被构造的对象
一般流程，通过Director解析构造Product所需要的参数并通过调用Builder接口调用具体的构造和装配接口，最后从ConcreteBuilder获得Product
（Director中有一个或多个Builder指针，指向Builder子类，由Director解析参数，再又Builder具体子类产生产品的全部或者部分再组装。）

1.3 工厂方法模式（factory method）
定义一个用于创建对象的接口，让子类决定实例化哪一个类。
适用范围：
1.当一个类不知道它所必须创建的对象的类的时候
2.当一个类希望由它的子类来指定它所创建的对象的时候
实现：
Product：定义工厂方法所创建的对象的接口
ConcreteProduct：实现Product接口
Creator：声明工厂方法，该方法返回一个Porduct类型的对象。Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。所以可以是具体类也可以是抽象类
ConcreteCreator：重定义工厂方法以返回一个ConcreteProduct实例
通过调用Creator的工厂方法来创建一个Product对象
（工厂只知道何时创建产品，不知道该创建什么产品。抽象工厂的接口是给客户用的，工厂方法的接口是给自己用的。例如 newProduct(){...createProduct();...};createProduct(){...};createProduct是工厂方法，由子类定义。）

1.4原型模式（Prototype）
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建的对象。
适用范围：
1.当要实例化的类是在运行时刻指定时
2.为了避免创建一个与产品类层次平行的工厂类层次
3.当一个类的实例只能有几个不同状态组合中的一种时
实现：
Prototype：声明一个克隆自身的接口
ConcretePrototype：实现一个克隆自身的接口
调用Prototype的克隆接口获得相应的ConcretePrototype
优点：
运行时刻增加和删除产品
缺点：
拷贝和原型管理问题

1.5单例模式（Singleton）
保证一个类仅有一个实例，并提供一个访问它的全局访问点
适用范围：
1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时
实现：
Singleton：实现一个Instance操作，允许客户访问它的唯一实例。
客户只能通过Singleton的Instance操作访问一个Singleton的实例

2.结构型模式
结构型类模式采用继承机制来组合接口或实现以获得更大的结构。结构型对象模式描述了如何对一些对象进行组合从而实现新功能的一些方法。

2.1适配器模式（adapter）
将一个类的接口转换成客户希望的另外一个接口。
适用范围：
1.希望使用一个已经存在但是接口不符合需求的类
2.希望创建一个可以复用的类，该类可以与其他不相关的类或者不可预见的类协同工作
3.希望使用一些已经存在的子类，但是不可能对每一个子类都进行子类化以匹配它们的接口，可以使用对象适配器适配它的父类接口
实现：
Target：定义Client使用的与特定领域相关的接口
Client：与符合Target接口的对象协同
Adaptee：定义一个已经存在的接口，这个接口需要适配
Adapter：对Adaptee的接口与Target接口进行适配
类适配器模式使用多重继承进行匹配，Adapter同时继承Target的接口和Adaptee的实现，用Adaptee的实现实现Target的接口。
对象适配器模式依赖对象组合进行匹配，Adapter继承Target的接口，Adaptee作为Adapter的一个成员变量（或者其他对象组合形式）

2.2桥接模式（bridge）
将抽象部分与它的实现部分分离，使它们都可以独立地变化。
适用范围：
1.不希望在抽象和它的实现部分之间有一个固定的绑定关系。
2.类的抽象以及它的实现都能通过生成子类的方法加以扩充。
3.对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。
实现：
Abstraction：定义抽象类的接口，维护一个指向Implementor类型对象的指针
RefinedAbstraction：Abstraction的子类，扩充由Abstraction定义的接口
Implementor：定义实现类的接口
ConcreteImplementor：Implementor的子类，实现Implementor接口并定义它的具体实现
Abstraction将client的请求转发给它的Implementor对象。
（Abstraction提供接口，Implementor提供实现，Abstraction包含Implementor指针成员变量。）

2.3组合模式（composite）
将对象组合成树形接口以表示“部分-整体”的层次接口，可以使得用户对单个对象和组合对象的使用具有一致性。
适用范围：
1.想要表达对象的部分-整体层次结构。
2.希望用户忽略组合对象和单个对象的不同，用户统一地使用组合结构中的所有对象。
实现：
Component：为组合的对象声明接口，声明一个接口用于访问和管理Component的字组件，在递归结构中可以定义一个用于访问一个父部件的接口。
Leaf：在组合中表示叶节点对象，叶节点没有子节点。在组合中定义图元对象的行为。
Composite：定义有子部件的那些部件的行为，存储子部件，在Component接口中实现与子部件有关的操作。
client：通过Component接口操纵组合部件的对象。
用户使用Component类接口和组合结构中的对象进行交互。

2.4装饰模式（decorator）
动态地给一个对象添加一些额外的职责。
适用范围：
1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
2.处理那些可以撤销的职责。
3.当不能采用生成子类的方法进行扩充时。
实现：
Component：定义一个对象接口，可以给这些对象动态地添加职责。
ConcreteComponent：定义一个对象，可以给这个对象添加一些职责。
Decorator：Component的子类，维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。
ConcreteDecorator：向组件添加职责。
Decorator将请求转发给它的Component对象，并有可能在转发前后执行一些附加的操作。
（装饰和被装饰接口相同，调用装饰的接口，装饰在调用被装饰接口前后添加一些操作。）

2.5外观模式（facade）
为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
适用范围：
1.为一个复杂子系统提供一个简单接口。
2.客户程序与抽象类的实现部分之间存在着很大的依赖性。
3.构建一个层次结构的子系统时，可以使用facade模式定义子系统中每层的入口点，让相互依赖的子系统仅通过facade进行通讯，简化它们的依赖关系。
实现：
Facade：知道哪些子系统负责处理请求，将客户的请求代理给适当的子系统对象。
Subsystem classes：实现子系统的功能，处理由Facade对象指派的任务。
客户程序通过发送请求给Facade的方式与子系统通讯，Facade将这些消息转发给适当的子系统对象。
（Facade为一个子系统提供一组接口）

2.6享元模式（flyweight）
运用共享技术有效地支持大量细粒度的对象。
适用范围：
一个应用程序适用了大量的对象，造成很大的存储开销。并且这些对象的大多数状态都可变为外部状态。如果删除对象的外部状态，那么可以用相对较少的共享对象取代很对组对象。应用程序不依赖于对象标识。
实现：
Flyweight：描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。
ConcreteFlyweight：实现Flyweight接口，并为内部状态增加存储空间。
UnsharedConcreteFlyweight：并非所有的Flyweight对象必须是可共享的。
FlyweightFactory：创建并管理flyweight对象。确保合理地共享flyweight。
Client：维持一个对flyweight的引用。计算或存储flyweight的外部状态。
flyweight执行所需的状态必定是内部和外部状态的结合。用户不应直接对ConcreteFlyweight类进行实例化，只能从FlyweightFactory对象得到ConcreteFlyweight对象，这可以保证对它们适当地进行共享。
（将可以共享的对象共享，节省内存。）

2.7代理模式（proxy）
为其他对象提供一种代理以控制对这个对象的访问。
适用范围：
1.远程代理（Remote Proxy）为一个对象在不同的地址空间提供局部代表。
2.虚代理（Virtual Proxy）根据需要创建开销很大的对象。
3.保护代理（Protection Proxy）控制对原始对象的访问，用于对象应该有不同的访问权限的时候。
4.智能指引（Smart Reference）取代了简单的指针，它在访问对象时执行一些附加操作，例如计数、自动释放、锁等。
实现：
Proxy：保存一个引用使得代理可以访问实体。若RealSubject和Subject的接口相同，Proxy会引用Subject。提供一个与Subject接口相同的接口，这样代理就可以用来代替实体。控制对实体的存取，并可能负责创建和删除它。其他功能依赖于代理的类型：Remote Proxy负责对请求及其参数进行编码，并向不同地址空间中的实体发送已编码的请求；Vritual Proxy可以缓存实体的附加信息，以便延迟对它的访问；Protection Proxy检查调用者是否具有实现一个请求所必须的访问权限。
Subject：定义RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。
RealSubject：定义Proxy所代表的实体。
Proxy根据其种类，在适当的时候向RealSubject转发请求。

3.行为模式
行为模式涉及到算法和对象间职责的分配。行为模式不仅描述对象或类的模式，还描述它们之间的通信模式，刻画了在运行时难以跟踪的复杂的控制流。行为类模式使用继承机制在类间分派行为，而行为对象模式使用对象复合。

3.1职责链模式（chain of responsibility）
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
适用范围：
1.有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2.在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3.可处理一个请求的对象集合应被动态指定。
实现：
Handler：定义一个处理请求的接口，（可选）实现后继链。
ConcreteHandler：处理它所负责的请求，可访问它的后继者。如果可以处理请求，则处理之，否则转给后继者。
Client：向链上的具体处理者对象提交请求。
当客户提交一个请求时，请求沿链传递直至有一个ConcreteHandler对象负责处理它。

3.2命令模式（command）
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化。
适用范围：
1.需要抽象出待执行的动作以参数化某对象。可用回调函数表达这种参数化机制。
2.在不同的时刻指定、排列和执行请求。
3.支持取消操作。
4.支持修改日志，这样当系统崩溃时，这些修改可以被重做一遍。
5.用构建在源于操作上的高层操作构造一个系统。类似于事物。
实现：
Command：声明执行操作的接口
ConcreteCommand：将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现Execute
Client：创建一个具体命令对象并设定它的接收者。
Invoker：要求该命令执行这个请求。
Receiver：知道如何实施和执行一个请求相关的操作。
Client创建一个ConcreteCommand对象并指定它的Receiver对象。某Invoker对象存储该ConcreteCommand对象。该Invoker通过调用Command对象的Execute操作来提交一个请求。若该命令是可撤销的，ConcreteCommand就在执行Execute操作之前存储当前状态以用于取消该命令。ConcreteCommand对象对调用它的Receiver的一些操作以执行该请求。
ConcreteCommand就是被封装的对象。

3.3解释器模式（interpreter）
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
适用范围：
1.当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。
实现：
AbstractExpression（ 抽象表达式）：声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
TerminalExpression（终结符表达式）：AbstractExpression的子类。实现与文法中的终结符相关联的解释操作。句子中的每个终结符需要该类的一个实例。
NonterminalExpression（非终结符表达式）：AbstractExpression的子类。对文法中的每一条规则都需要一个NonterminalExpression类。为每个符号都维护一个AbstractExpression类型的实例变量。为文法中的非终结符实现解释（Interpret）操作。解释（Interpret）一般要递归地调用表示那些对象的解释操作。
Context（上下文）：包含解释器之外的一些全局信息。
Client：构建（或被给定）表示该文法定义的语言中一个特定的句子的抽象语法树。该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。调用解释操作。
Client构建（或被给定）一个句子，它是NonterminalExpression和TerminalExpression的实例的一个抽象语法树。然后初始化上下文并调用解释操作。每一非终结符表达式节点定义相应子表达式的解释操作。而各终结符表达式的解释操作构成了递归的基础。每一节点的解释操作用上下文来存储和访问解释器的状态。

3.4迭代器模式（iterator）
提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。
适用范围：
1.访问一个聚合对象的内容而无需暴露它的内部表示。
2.支持对聚合对象的多种遍历。
3.为遍历不同的聚合结构提供一个统一的接口。
实现：
Iterator：迭代器定义访问和遍历元素的接口。
ConcreteIterator：具体迭代器实现迭代器接口，对该聚合遍历时跟踪当前位置。
Aggregate：聚合定义创建相应迭代器对象接口。
ConcreteAggregate：具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。
ConcreteIterator跟踪聚合中的当前对象，并能够计算出待遍历的后继对象。

3.5中介者模式（mediator）
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
适用范围：
1.一组对象以良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。
2.一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。
3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。
实现：
Mediator：中介者定义一个接口用于与各Colleague对象通信。
ConcreteMediator：具体中介者通过协调各Colleague对象实现协作行为。了解并维护它的各个Colleague。
Colleague：每个Colleague类都知道它的中介者对象。每个Colleague对象在需与其他的Colleague通信时，与它的中介者通信。
Colleague向一个Mediator对象发送和接收请求，Mediator在各Colleague间适当地转发请求以实现协作行为。

3.6备忘录模式（memento）
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可将该对象回复到原先保存的状态。
适用范围：
1.必须保存一个对象在某一个时刻的状态，这样以后需要时它才能恢复到先前的状态。
2.如果一个用接口来让其他对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。
实现：
Memento：存储Originator对象的内部状态。防止Originator以外的其他对象访问备忘录。
Originator：创建一个Memento用以记录当前时刻它的内部状态。使用Memento恢复内部状态。
Caretaker：负责保存好Memento。不能对Memento的内容进行操作或检查。
Caretaker向Originator请求一个Memento，当需要时将其送回给Originator。

3.7观察者模式（observer）
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
适用范围：
1.当一个抽象模型有两个方面，其中一个方面依赖另一个方面。
2.当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变。
3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换而言之，你不希望这些对象是紧耦合的。
实现：
Subject：目标制定它的观察者。提供注册和删除观察者对象的接口。
Observer：为那些在目标发生改变时需获得通知的对象定义一个更新接口。
ConcreteSubject：将有关状态存入各ConcreteObserver对象。当它的状态发生改变时，向它的各个观察者发出通知。
ConcreteObserver：维护一个指向ConcreteSubject对象的引用。存储有关状态。实现Observer的更新接口以使自身状态与目标状态保持一致。
当ConcreteSubject发生任何可能导致其观察者与其本身状态不一致的改变时，它将通知它的各个观察者。在等到一个具体目标的改变通知后，ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象的状态一致。

3.8状态模式（state）
允许一个对象在其内部状态改变时改变它的行为。
适用范围：
1.一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。
2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。
实现：
Context：定义用户感兴趣的接口。维护一个ConcreteState子类的实例，这个实例定义当前状态。
State：定义一个接口以封装与Context的一个特定状态相关的行为。
ConcreteState subclasses：每一子类实现一个与Context的一个状态相关的行为。
Context将与状态相关的请求委托给当前的ConcreteState对象处理。Context可将自身作为一个参数传递给处理该请求的状态对象，这使得状态对象在必要时可以访问Context。Context是客户使用的主要接口。
Context包含一个State指针，用户感兴趣的接口实际调用State的操作。

3.9策略模式（strategy）
定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。
适用范围：
1.许多相关的类仅仅是因为行为有异。
2.需要使用一个算法的不同变体。
3.一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句额形式出现。
实现：
Strategy：定义所有支持的算法的公共接口。
ConcreteStrategy：以Strategy接口实现某具体算法。
Context：用一个ConcreteStrategy对象来配置。维护一个对Strategy对象的引用。
Strategy和Context相互作用以实现选定的算法。Context将它的客户的请求转发给它的Strategy。
实际模式架构与状态模式相同

3.10模板方法模式（template method）
定义一个操作中的算法的骨架，而将一些步骤的实现延迟到子类中。
适用范围：
1.一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。
3.控制子类的扩展。
实现：
AbstractClass：定义抽象的原语操作，具体的子类将重定义它们以实现一个算法的各步骤。实现一个模板方法，定义一个算法的骨架。
ConcreteClass：实现原语操作以完成算法中与特定子类相关的步骤
ConcreteClass靠AbstractClass来实现算法中不变的步骤。
算法中变的部分为AbstractClass的虚函数，由子类ConcreteClass实现。

3.11访问者模式（visitor）
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用这些元素的新操作。
适用范围：
1.一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
2.需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象类。
3.定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。
实现：
Vistor：为该对象结构中的ConcreteElement的每一个类声明一个Visit操作。
ConcreteVisitor：实现每个由Visitor声明的操作。
Element：定义一个Accept操作，它以一个访问者为参数。
ConcreteElement：实现Accept操作。
ObjectStructure：能枚举它的元素。可以提供一个高层的接口以允许该访问者访问它的元素。
一个使用Visitor模式的客户必须创建一个ConcreteVisitor对象，然后遍历该对象结构，并用该访问者访问每一个元素。当一个元素被访问时，它调用对应于它的类的Visitor操作。
Element定义一个Accept操作，它以一个Vistor为参数，在函数中调用Vistor的接口进行操作。