设计模式总结

自己总结

1.我们的目的是使用设计模式利用面向对象思想完成任务，构建不同的类。类需要通过main函数（即大话设计模式中的客户端程序）实例化完成任务。
2.《大话设计模式》讲的比较通俗易懂，但是废话比较多，和博客一样，《设计模式-可复用面向对象软件的基础》条理清晰，初次接触不太好理解。可以先看《大话设计模式》，在用《设计模式-可复用面向对象软件的基础》查阅。

《大话设计模式》总结

本书以大鸟和小菜对话的方式介绍23种设计模式。面向对象程序几个重要特性(P5),这些特性便于实际中优化代码和添加新的需求，面向对象语言通过封装、继承和多态可降低程序的耦合性，实现这些特性：
1）可维护性：方便后期增加和删除功能；
2）可复用性：代码的复用性较高，如子类继承父类可提高代码复用性；用类构造不同的实例，也可看作在复用类的代码；可以复制的代码段都可以封装为类或函数
3）可扩展性：如方法重载可提高函数的扩展性
4）灵活性：

1、简单工厂（Factory）模式-对象创建型

简单工厂用一个单独的工厂类创造实例，决定实例化谁，将来增加实例化的对象。
其优点是面对程序变动，只需改变工厂类即可，但缺点也是如果经常变动，需要经常改动这个工厂，重新编译部署代码(指客户端代码)。

2、策略模式-对象行为型

策略模式定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户(指客户端代码)。
简单工厂返回的是类，而策略模式的Context封装了算法，封装了任何类的规则，直接返回结果。

3、单一职责原则

**就一个类而言，应该仅有有一个引起它变化的原因。**这样可以减少耦合，易复用，易扩展，维护更简单，更加灵活。如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责，就应该考虑类的职责分离。

4、开放-封闭原则

**软件实体(类、模块和函数等)应该可以扩展，但是不可修改。对于扩展时开放的，对于修改是封闭的。**多扩展、少修改更容易维护，可减少出错的机会。需对程序中呈现频繁变化的那些部分做出抽象，过分抽象也不是一个好主意。

5、依赖倒转原则

**高层模块不应该依赖低层模块。两个都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。（即针对接口编程，不要针对实现编程）**高层指应用层，低层指底层算法库等，高层和低层都依赖接口或抽象类编程比较好，抽象类一般是父类。
**里式代换原则：子类型必须能够替换掉它们的父类。**一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。把父类替换成子类，程序的行为没有变化。那么子类可以扩展父类的功能。

6、装饰模式-对象结构型

**动态地给一个对象添加一些额外地职责，就增加功能来说，装饰模式比生成子类更为灵活。**通过回调(openration)的方式完成原本职责，再通过AddedBehavior()动态添加新的职责，该职责在运行时才知道用的是哪个子类，具体做什么，所以是动态的。

7、代理模式-对象结构

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

8、工厂（Factory）方法模式-对象创建型

**定义一个用于创建对象的接口，让（工厂类）子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。**简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的关联，缺点是简单工厂类违背了开放-封闭的原则。于是有了工厂方法，其需要修改客户端，但只要修改一处即可。利用反射模式可避免分支判断的问题。

9、原型模式-对象创建型

**用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。**一般在初始化的信息不发生变化的情况下，克隆是最好的方法。这既隐藏了对象创建的细节，又对性能是大大的提高，减少构造函数的执行时间。浅复制只复制引用，不复制引用所指对象，深复制复制引用所指对象。

10、模板方法模式-类行为型

**定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。**重复的代码易错且难改，模板方法模式通过把不变行为搬移到超类，去除子类中的重复代码。

11、迪米特法则

**如果两个类不必彼此直接通信，那么这两个类就不当发生直接的相互作用。如果其中一个类需要调用另一个类的某个方法的话，可以通过第三种转发这个调用。也叫最少知识原则。**在类的结构设计上，每个类都应尽量降低成员的访问权限，迪米特法则强调了类之间的松耦合，类之间耦合越弱，越有利于复用。一个处在弱耦合的类被修改，不会对有关系的类造成波及。

12、外观模式-对象结构型

**为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。**使用外观模式的三个阶段：首先，在设计初期阶段，应该要有意识将两个层分离，如ROS作为传感器和算法的中间层。其次，在开发阶段，子系统往往因为不断地重构演化而变得越来越复杂，产生很多很小地类，不利于用户程序调用，增加外观模式可以提供一个简单地接口，减少耦合性。第三，在维护一个遗留地大型系统时，可能该系统非常难以维护和扩展了，可以使用外观模式，增加中间层，方便新系统和老系统交互。

13、建造者(生成器)模式-对象创建型

**将一个复杂对象地构建（在director里）与它的表示（在builder和它子类里）分离，使得同样的构建过程可以创建不同的表示。**建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时使用的模式。子类一定要重写构建步骤中每个函数，否则编译都不能通过。

14、观察者模式-对象行为型

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。当一个对象的改变需要同时改变其他对象，且不知道有多少对象需要改变时，可以使用观察者模式，这样也可以消除两个类之间的耦合性。使用事件委托可以使用同一观察者通知不同的类，但要求不同类具有相同的参数列表和返回值类型。

15、抽象工厂（Abstract Factory）模式-对象创建型

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。该模式最大的好处便是易于交换产品系列。第二个好处是它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。反射可以利用字符串来，而字符串变量是可以替换的，可使用读配置文件方式读入字符串，可以克服使用switch时需要修改代码的问题*

16、状态模式-对象行为型

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。适用于对象的行为取决于它的状态且需要在运行时根据状态改变它的行为的情况，主要解决控制一个对象状态转换的条件表达式过于复杂的情况，其将状态的判断逻辑转移到表示不同状态的一系列类当中，可以简化判断逻辑，消除庞大的条件分支语句。逻辑判断执行行为时实现。好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。
注：函数过长不好。

17、适配器模式-类对象结构型

将一个类的接口转换成客户希望的另外一个接口。该模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。适用于系统的数据和行为都正确，但接口不符情况。短期难以更改系统接口，则可以考虑使用适配器以便调用系统算法。适配器包括类适配器和对象适配器。

18、备忘录模式-对象行为型

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。使用备忘录可以把复杂的对象内部信息对其他的对象遮蔽起来。

19、组合模式-对象结构型

将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。组合模式可以让客户一致地使用组合结构和单个对象。
注：透明方式与安全方式，透明方式有无用功，更通用；安全方式无无用功，但要区分用哪个类

20、迭代器模式-对象行为型

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

21、单例模式-对象创建型

保证一个类仅有一个实例，并提供访问它的全局访问点。将构造方法声明为private，防止外部实例化，使用public地GetInstance调用private构造方法实例化，可以只返回一个实例。

22、桥接模式-对象结构型

将抽象部分与它的实现部分分离，使他们可以独立地变化。即让抽象类与其派生类分离，如文中让“手机”既可以按照品牌来分类，也可以按照功能来分类。
注：合成/聚合复用原则：尽量使用合成/聚合，尽量不要使用继承。聚合表示一种弱的拥有关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分，如雁群和大雁；合成则是一种强的拥有关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样，如大雁和翅膀。继承适合“is-a”关系，即A是B。

23、命令模式-对象行为型

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。其优点：1）较容易设计一个命令队列；2）在需要的情况下，可以较容易地将命令记入日志；3）允许接收请求地一方决定是否要否决请求；4）可以容易地实现对请求地撤销和重做；5）由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易。6）把请求一个操作的对象与知道怎么执行一个操作的对象分割开来。

24、职责链模式-对象行为型

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。优点：接收者和发送者都没有对方的明确信息，且链中对象自己也并不知道链的结构。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。

25、中介者模式-对象行为型

又叫调停者模式，用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的相互引用，从而使其耦合松散，而且可以独立地改变它们之间地交互。当系统出现“多对多”交互复杂的对象群时，不要急于使用中介者模式，而要反思系统设计是否合理，否则容易误用。一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合。

26、享元模式-对象结构型

运用共享技术有效地支持大量细粒度地对象。内部状态存储于concreteflyweight对象中，外部状态又客户端对象存储或计算。如果一个应用程序使用了大量对象，造成了很大地存储开销，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，考虑使用享元模式，

27、解释器模式-类行为模型

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。正则表达式是解释模式的一种应用。

28、访问者模式-对象行为型

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。双分派技术中，得到执行的操作不仅决定于“状态”类的具体状态，还决定于它访问的“人”的类别。它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。如果系统又比较稳定的数据结构，又有易于变化的算法，比较适合使用访问者模式。状态即访问者visitor，增加新的操作就意味者增加一个新的访问者。缺点使增加新的数据结构变得困难。

29、模式总结

面向对象方法可以封装变化区域，更容易将代码与变化产生的影响隔离开来。创建型在创建什么、谁创建它、如何创建、何时创建提供了很大的灵活性。

30、附录A-面向对象基础

以C#为例

1.类与实例

类就是具有相同的属性和功能的对象的抽象的集合；实例就是一个真实对象，对象是一个自包含的实体，用一组可识别的特性和行为来标识。可用类和实例秒速一切事物，首先可将万物分为不同类，然后通过创建类的实例，构造一个具体的对象。如人类具有相同的熟悉和功能，通过实例化可创建张三和李四等具体的某个人。因此，在程序设计中需要根据整个程序框架，设计好不同的类
类中包括变量、方法(函数)和操作符等,pulic修饰的可在其它地方通过类实例调用，而protect和private修饰的只能类实例中函数使用。

2.构造方法

类中的构造函数是类的构造方法，用于构造类的实例，对类进行初始化，在内存中开辟一片空间。

3.方法(函数)重载

方法重载提供了创建同名的多个方法的能力，但这些方法需要使用不同的参数类型或个数。好处是在不改变原方法的基础上，新增功能，提高函数的可扩展性。

4.属性与修饰符

属性是一个方法或一对方法，但在调用它的代码看来，它是一个字段，即属性使用于以字段的方式使用方法调用的场合。**通常字段是私有变量，属性是共有变量。**一个字段可通过属性的get和set函数改变，加一层属性可防止外部直接改变类的变量，多层保护，但这样想操作类更麻烦一点。

5.封装

每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其它对象来完成自己的操作。封装的好处：1）减少耦合；2）类内部的实现可以自由修改，便于维护；3）类具有清晰的对外接口。

6.继承

对象的继承代表了一种"is-a"的关系，如果两个对象A和B，可以描述为“B是A”，则表明B可以继承A，即小类可以继承大类，如猫和狗都能继承哺乳动物。如果子类继承于父类，1）子类拥有父类非private(protected、public)的属性和功能；2）子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能；3）子类还可以以自己的方式实现父类的功能（方法重写）。继承可提高代码的复用率。但继承会破坏包装，父类实现细节暴露给子类，会增强两个类之间耦合关系。

7.多态

多态表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行。子类以父类身份出现，子类特有的属性和方法不可用。这对应C++中的虚函数(virtual),其在父类中声明，可在子类中方法重写override，纯虚函数(=0)必须在子类中方法重写。这种对象在声明时可以父类声明，但在调用虚函数实现时，以子类方法实现。多态的原理是当方法被调用时，无论对象是否转换为父类，都只有继承链最末端的方法实现会被调用。即虚方法按照其运行时类型而非编译时类型进行动态绑定调用。

8.重构

重构指在完成代码后，重新架构代码，改善现有代码的设计，如通过重构设计抽象类，提高代码复用率。

9.抽象类

抽象(abstract)类不能实例化，如哺乳动物我们想象不出它的样子；抽象方法是必须被子类重写的方法，即纯虚方法；如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否包含其它方法。抽象类通常代表一个抽象概念，它提供一个继承的出发点，当设计一个新的抽象类时，一定用来继承的。所以，在一个以继承关系形成的等级结构中，树叶节点应当时具体类(可实例化的)，而树枝节点均应当时抽象类[J&DP]。

10.接口

接口和抽象类类似，声明方法相同，但不允许提高接口中任何成员的执行方式，所以接口不能实例化，不能有构造方法和字段，不能有修饰符，不能声明虚拟或静态等。实现接口的类就必须实现接口中的所有方法和属性。一个类可支持多个接口，多个类也可以支持相同的接口。类是对对象的抽象，抽象类是对类的抽象，接口是对行为的抽象，接口常用于实现不同类的相同行为。

11.集合

集合用于数据存储和检索的专用类，提供对堆栈、队列、列表和哈希表的支持。集合可按需动态增删对象，但这个过程装箱和拆箱需耗费大量资源和时间。

12.泛型

泛型有点类似模板类，可以将类型参数用作它所存储的对象的类型的占位符，类型参数作为其字段和其方法的参数类型。

13.委托与事件

委托(delegate)是对函数的封装，可以当作给方法的特征指定一个名称，而事件(event)则是委托的一种特殊形式，当发生有意义的事件是，事件对象处理通知过程。

《设计模式-可复用面向对象软件的基础》_埃里克 伽玛、李英军译

所有面向对象系统结构中包含了许多设计模式，本书精选23个模式。评价面向对象系统的质量时，判断设计者是否强调了对象之间的公共协同关系，其使得系统结构更加精巧、简洁和易于理解，增加软件的灵活性、模块化和可复用性。本书两个重要贡献：1）展示了模式在软件系统中角色；2）提供了引用模式的实用方法。本书将模式分为三种类型：创建型、结构型和行为型。

1、引言

设计面向对象软件比较困难，而设计可复用的面向对象软件就更加困难。你必须找到相关的对象，以适当的粒度将它们归类，再定义类的接口和继承层次，建立对象之间的基本关系。设计应该针对当前问题，同时对将来的问题和需求也要有足够的通用性。好的软件设计往往需要多次重构。
模式包括模式名、问题（描述在何时使用模式）、解决方案（秒速了设计的组成成分、它们之间的相互关系及各自的指着和协作方式）和效果（描述了模式应用的效果及使用模式应权衡的问题）四个基本要素。
根据模式的目的可分为创建型、结构型和行为型。创建型与对象的创建有关；结构性处理类或对象的组合；行为型对类或对象怎样交互和怎么样分配职责进行描述。
根据模式的范围可分为用于类还是用于对象。类模式处理类和子类之间的关系，这些关系通过继承建立，是静态的，在编译时便确定下来了。对象模式处理对象间的关系，**这些关系是可以变化的，更具动态性。**所以类模式只指那些集中于处理类间关系的模式，而大部分模式属于对象模式的范畴。
设计模式空间如下：

创建型类模式将对象的部分创建工作延迟到子类，而创建型对象模式则将它延迟到另一个对象中。结构型类模式使用继承机制来组合类，而结构型对象模式则描述了对象的组装方式。行为型类模式使用继承描述算法和控制流，行为型对象模式则描述了一组对象怎样协作完成单个对象所无法完成的任务。
还有其他组织模式的方式。有些模式经常会被捆绑一起使用，如composite和iterator或visitor一起使用；有些是可替代的，如，prototype常用来替代abstract factory；有些模式尽管使用意图不同，但产生的设计结果很相似，如composite和decorator的结构图相似。
模式关系图如下图。

设计模式怎样解决设计问题

1.寻找合适的对象
面向对象的程序由对象组成，对象包括数据和对数据进行操作的过程，过程称为方法或操作。对象在收到客户请求（或消息）后，执行相应的操作。
客户请求是使对象执行操作的唯一方法，操作又是对象改变内部数据的唯一方法。面向对象设计最困难的部分使将系统分解成对象集合。需要权衡封装、粒度、依赖关系、灵活性、性能、演化、复用等因素，它们之间通常还是相互冲突的。
2.决定对象的粒度
对象在大小和数目上变化极大。
3.指定对象接口
对象操作所定义的所有操作型构的集合称为该对象的接口。对象接口描述了该对象所能接受的全部请求的集合。
发送给对象的请求和它的相应操作在运行时的连接称为动态绑定，即多态。
4.描述对象的实现
对象的实现由它的类决定。OMT表示法用三层矩形（类名，操作，数据）表示类。
抽象类将它的部分或全部操作的实现延迟到子类中，如虚函数。
混入类是给其他类提供可选择的接口或功能的类。它与抽象类一样不能实例化，但混入类要求多继承，子类除了继承混入类还继承了其他类。
只根据抽象类定义接口操作对象的好处，即虚函数或多态的好处：
1）客户（类外的都可看成客户）无须知道他们使用对象的特定类型，只需知道对象有客户所期望的接口；
2）客户无需知道他们使用的对象是用什么类来实现的，只需要知道定义接口的抽象类。
这将极大减少子系统实现之间的相互依赖关系，也产生了可复用的面向对象设计的针对接口编程，而不是针对实现编程原则。
5.运用复用机制
常用复用技术是继承和对象组合。继承的缺点是会破坏父类的封装性，是在编译时静态定义的，而对象组合荣光获得对其他对象的引用而在运行时动态定义的。其不破坏封装性，运行时可用一个对象来替代另一个对象，依赖关系较少。第二个设计原则是优先使用对象组合，而不是类继承****委托是一种组合方法，它使组合具有与继承同样的复用能力。在委托方式下，有两个对象参与处理一个请求，接受请求的对象将操作委托给它的代理者。
模板是第三种复用技术，是静态的，本书没有一种模式用到模板。
6.关联运行时和编译时结构
面向对象程序运行时的结构通常与它的代码结构相差较大。对象聚合和相识很容易混淆，因为它们通常以相同的方法实现。聚合意味着一个对象拥有另一个对象或对另一个对象负责，一般称为一个对象包含另一个对象或是另一个对象的一部分。两者具有相同的生命周期。聚合可以通过定义表示真正实例的成员变量来实现，但更通常的是将这些成员变量定义为实例指针或引用。
相识意味着一个对象仅仅知道另一个对象，又是相识也被称为”关联“或”引用“的关系，两者关系比聚合弱。相识也是用指针或引用实现的。
7.设计应支持变化
获得最大限度复用的关键在于对新需求和已有需求发生变化时的预见性，要求系统设计能够相应地改进。变化可能是类的重新定义和实现，修改客户和重新测试。
**导致重新设计地一般原因和解决这些问题的设计模式。**P19
1）通过显示指定一个类来创建对象
2）对特殊操作的依赖
3）对硬件和软件平台的依赖
4）对对象表示或实现的依赖
5）算法依赖
6）紧耦合
7）通过生成子类来扩充功能
8）不能方便地对类进行修改
7.怎样选择设计模式P22
8.怎样使用设计模式

2、实例研究：设计一个文档编辑器

3、创建型模式

创建型设计模式抽象了实例化过程。它们帮助一个系统独立于如何创建、组合和表示它的那些对象。一个类创建型模式使用继承改变被实例化的类，而一个对象创建型模式将实例化委托给另一个对象。

3.1　Abstract Factory（抽象工厂）—对象创建型模式┊66

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

3.2　Builder（生成器）—对象创建型模式┊74

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

3.3　Factory Method（工厂方法）—对象创建型模式┊81

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

3.4　Prototype（原型）—对象创建型模式┊89

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

3.5　Singleton（单件）—对象创建型模式┊96

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

3.6　创建型模式的讨论┊102

4、结构性模式

4.1　Adapter（适配器）—类对象结构型模式┊106

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

4.2　Bridge（桥接）—对象结构型模式┊115

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

4.3　Composite（组合）—对象结构型模式┊123

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

4.4　Decorator（装饰）—对象结构型模式┊132

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

4.5　Facade（外观）—对象结构型模式┊┊139

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

4.6　Flyweight（享元）—对象结构型模式┊146

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

4.7　Proxy（代理）—对象结构型模式┊155

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

4.8　结构型模式的讨论 ┊164

5、行为型模式

5.1　Chain of Responsibility（职责链）—对象行为型模式┊167

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

5.2　Command（命令）—对象行为型模式┊175

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

5.3　Interpreter（解释器）—类行为型模式┊183

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

5.4　Iterator（迭代器）—对象行为型模式┊193

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

5.5　 Mediator（中介者）—对象行为型模式┊205

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

5.6　Memento（备忘录）—对象行为型模式┊212

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

5.7　Observer（观察者）—对象行为型模式┊219

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

5.8　State（状态）—对象行为型模式┊227

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

5.9　Strategy（策略）—对象行为型模式┊234

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

5.10　Template Method（模板方法）— 类行为型模式┊242

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

5.11　Visitor（访问者）—对象行为型 模式┊246

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

5.12　行为型模式的讨论┊256

6、结论