设计模式可复用面向对象软件的基础 第5章 行为模式.docx

《设计模式可复用面向对象软件的基础 第5章 行为模式.docx》由会员分享，可在线阅读，更多相关《设计模式可复用面向对象软件的基础 第5章 行为模式.docx（76页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、第5章行为模式行为模式涉及到算法和对象间职责的分配。行为模式不仅描述对象或类的模式，还描述它们之间的通信模式。这些模式刻划了在运行时难以跟踪的复杂的控制流。它们将你的注意力从控制流转移到对象间的联系方式上来。行为类模式使用继承机制在类间分派行为。本章包括两个这样的模式。其中 Te m p l a t e M e t h o d（5 . 1 0）较为简单和常用。模板方法是一个算法的抽象定义，它逐步地定义该算法，每一步调用一个抽象操作或一个原语操作，子类定义抽象操作以具体实现该算法。另一种行为类模式是I n t e r p r e t e r（5 . 3）。它将一个文法表示为一个类层次，并实现一个

2、解释器作为这些类的实例上的一个操作。行为对象模式使用对象复合而不是继承。一些行为对象模式描述了一组对等的对象怎样相互协作以完成其中任一个对象都无法单独完成的任务。这里一个重要的问题是对等的对象如何互相了解对方。对等对象可以保持显式的对对方的引用，但那会增加它们的耦合度。在极端情况下，每一个对象都要了解所有其他的对象。 M e d i a t o r（5 . 5）在对等对象间引入一个 m e d i a t o r对象以避免这种情况的出现。 m e d i a t o r提供了松耦合所需的间接性。 Chain of Responsibility(5.1)提供更松的耦合。它让你通过一条候选对象链隐

3、式的向一个对象发送请求。根据运行时刻情况任一候选者都可以响应相应的请求。候选者的数目是任意的，你可以在运行时刻决定哪些候选者参与到链中。 O b s e r v e r ( 5 . 7 )模式定义并保持对象间的依赖关系。典型的 O b s e r v e r的例子是Smalltalk 中的模型/视图/控制器，其中一旦模型的状态发生变化，模型的所有视图都会得到通知。其他的行为对象模式常将行为封装在一个对象中并将请求指派给它。 S t r a t e g y ( 5 . 9 )模式将算法封装在对象中，这样可以方便地指定和改变一个对象所使用的算法。 C o m m a n d ( 5 . 2 )模式

4、将请求封装在对象中，这样它就可作为参数来传递，也可以被存储在历史列表里，或者以其他方式使用。 S t a t e ( 5 . 8 )模式封装一个对象的状态，使得当这个对象的状态对象变化时，该对象可改变它的行为。 Vi s i t o r ( 5 . 11 )封装分布于多个类之间的行为，而 I t e r a t o r ( 5 . 4 )则抽象了访问和遍历一个集合中的对象的方式。 5.1 CHAIN OF RESPONSIBILITY(职责链)对象行为型模式 1. 意图使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一

5、个对象处理它为止。 2. 动机考虑一个图形用户界面中的上下文有关的帮助机制。用户在界面的任一部分上点击就可以得到帮助信息，所提供的帮助依赖于点击的是界面的哪一部分以及其上下文。例如，对话框中的按钮的帮助信息就可能和主窗口中类似的按钮不同。如果对那一部分界面没有特定的帮助信息，那么帮助系统应该显示一个关于当前上下文的较一般的帮助信息比如说，整个对话框。因此很自然地，应根据普遍性 ( g e n e r a l i t y )即从最特殊到最普遍的顺序来组织帮助信息。而且，很明显，在这些用户界面对象中会有一个对象来处理帮助请求 ;至于是哪一个对象则取决于上下文以及可用的帮助具体到何种程度。这儿的问题

6、是提交帮助请求的对象(如按钮)并不明确知道谁是最终提供帮助的对象。我们要有一种办法将提交帮助请求的对象与可能提供帮助信息的对象解耦 ( d e c o u p l e )。Chain of R e s p o n s i b i l i t y模式告诉我们应该怎么做。这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者。该请求沿对象链传递直至其中一个对象处理它，如下图所示。从第一个对象开始，链中收到请求的对象要么亲自处理它，要么转发给链中的下一个候选者。提交请求的对象并不明确地知道哪一个对象将会处理它我们说该请求有一个隐式的接收者(implicit receiver)。假设用

7、户在一个标有 “P r i n t”的按钮窗口组件上单击帮助，而该按钮包含在一个 P r i n t D i a l o g的实例中，该实例知道它所属的应用对象 (见前面的对象框图 )。下面的交互框图 (diagram) 说明了帮助请求怎样沿链传递 :在这个例子中，既不是 aPrintButton 也不是 aPrintDialog 处理该请求 ;它一直被传递给 a n A p p l i c a t i o n，anApplication 处理它或忽略它。提交请求的客户不直接引用最终响应它的对象。要沿链转发请求，并保证接收者为隐式的( i m p l i c i t )，每个在链上的对象都有一

8、致的处理请求和访问链上后继者的接口。例如，帮助系统可定义一个带有相应的HandleHelp 操作的H e l p H a n d l e r类。HelpHandler 可为所有候选对象类的父类，或者它可被定义为一个混入（m i x i n）类。这样想处理帮助请求的类就可将HelpHandler 作为其一个父类，如下页上图所示。按钮、对话框，和应用类都使用 HelpHandler 操作来处理帮助请求。 H e l p H a n d l e r的 HandleHelp 操作缺省的是将请求转发给后继。子类可重定义这一操作以在适当的情况下提供帮助；否则它们可使用缺省实现转发该请求。 3. 适用性在以

9、下条件下使用 Responsibility 链： 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 可处理一个请求的对象集合应被动态指定。 4. 结构一个典型的对象结构可能如下图所示 : 5. 参与者 H a n d l e r（如H e l p H a n d l e r）定义一个处理请求的接口。（可选）实现后继链。 C o n c r e t e H a n d l e r（如P r i n t B u t t o n和P r i n t D i a l o g）处理它所负责的请求。可访问它的后继者。如果可

10、处理该请求，就处理之；否则将该请求转发给它的后继者。 C l i e n t向链上的具体处理者 ( C o n c r e t e H a n d l e r )对象提交请求。 6. 协作 当客户提交一个请求时，请求沿链传递直至有一个 ConcreteHandler 对象负责处理它。 7. 效果 Responsibility 链有下列优点和缺点( l i a b i l i t i e s ) : 1 )降低耦合度该模式使得一个对象无需知道是其他哪一个对象处理其请求。对象仅需知道该请求会被“正确”地处理。接收者和发送者都没有对方的明确的信息，且链中的对象不需知道链的结构。结果是，职责链可简化对

11、象的相互连接。它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。 2) 增强了给对象指派职责 ( R e s p o n s i b i l i t y )的灵活性当在对象中分派职责时，职责链给你更多的灵活性。你可以通过在运行时刻对该链进行动态的增加或修改来增加或改变处理一个请求的那些职责。你可以将这种机制与静态的特例化处理对象的继承机制结合起来使用。 3) 不保证被接受既然一个请求没有明确的接收者，那么就不能保证它一定会被处理 该请求可能一直到链的末端都得不到处理。一个请求也可能因该链没有被正确配置而得不到处理。 8. 实现下面是在职责链模式中要考虑的实现问题 : 1)

12、 实现后继者链有两种方法可以实现后继者链。 a) 定义新的链接(通常在H a n d l e r中定义，但也可由ConcreteHandlers 来定义)。 b) 使用已有的链接。我们的例子中定义了新的链接，但你常常可使用已有的对象引用来形成后继者链。例如，在一个部分整体层次结构中，父构件引用可定义一个部件的后继者。窗口组件（ Wi d g e t）结构可能早已有这样的链接。 C o m p o s i t e（4 . 3）更详细地讨论了父构件引用。当已有的链接能够支持你所需的链时，完全可以使用它们。这样你不需要明确定义链接，而且可以节省空间。但如果该结构不能反映应用所需的职责链，那么你必须定

13、义额外的链接。 2) 连接后继者如果没有已有的引用可定义一个链，那么你必须自己引入它们。这种情况下 H a n d l e r不仅定义该请求的接口，通常也维护后继链接。这样 H a n d l e r就提供了 H a n d l e R e q u e s t的缺省实现 : H a n d l e R e q u e s t向后继者 (如果有的话 )转发请求。如果 ConcreteHandler 子类对该请求不感兴趣，它不需重定义转发操作，因为它的缺省实现进行无条件的转发。此处为一个H e l p H a n d l e r基类，它维护一个后继者链接： 3) 表示请求可以有不同的方法表示请求。

14、最简单的形式，比如在 H a n d l e H e l p的例子中，请求是一个硬编码的 (hard-coded) 操作调用。这种形式方便而且安全，但你只能转发 H a n d l e r类定义的固定的一组请求。另一选择是使用一个处理函数，这个函数以一个请求码 (如一个整型常数或一个字符串 )为参数。这种方法支持请求数目不限。唯一的要求是发送方和接受方在请求如何编码问题上应达成一致。这种方法更为灵活，但它需要用条件语句来区分请求代码以分派请求。另外，无法用类型安全的方法来传递请求参数，因此它们必须被手工打包和解包。显然，相对于直接调用一个操作来说它不太安全。为解决参数传递问题，我们可使用独立的

15、请求对象来封装请求参数。 R e q u e s t类可明确地描述请求，而新类型的请求可用它的子类来定义。这些子类可定义不同的请求参数。处理者必须知道请求的类型(即它们正使用哪一个R e q u e s t子类)以访问这些参数。为标识请求，R e q u e s t可定义一个访问器 ( a c c e s s o r )函数以返回该类的标识符。或者，如果实现语言支持的话，接受者可使用运行时的类型信息。以下为一个分派函数的框架 ( s k e t c h )，它使用请求对象标识请求。定义于基类 R e q u e s t中的 G e t K i n d操作识别请求的类型:子类可通过重定义 H a

16、 n d l e R e q u e s t扩展该分派函数。子类只处理它感兴趣的请求；其他的请求被转发给父类。这样就有效的扩展了 (而不是重写 ) H a n d l e R e q u e s t操作。例如，一个 E x t e n d e d H a n d l e r子类扩展了M y H a n d l e r版本的H a n d l e R e q u e s t :4) 在S m a l l t a l k中自动转发你可以使用Smalltalk 中的d o e s N o t U n d e r s t a n d机制转发请求。没有相应方法的消息被 doseNotUnderstand

17、 的实现捕捉（trap in），此实现可被重定义，从而可向一个对象的后继者转发该消息。这样就不需要手工实现转发；类仅处理它感兴趣的请求，而依赖doesNotUnderstand 转发所有其他的请求。 9. 代码示例下面的例子举例说明了在一个像前面描述的在线帮助系统中，职责链是如何处理请求的。帮助请求是一个显式的操作。我们将使用在窗口组件层次中的已有的父构件引用来在链中的窗口组件间传递请求，并且我们将在 H a n d l e r类中定义一个引用以在链中的非窗口组件间传递帮助请求。 HelpHandler 类定义了处理帮助请求的接口。它维护一个帮助主题 (缺省值为空)，并保持对帮助处理对象链中它

18、的后继者的引用。关键的操作是 H a n d l e H e l p，它可被子类重定义。 HasHelp 是一个辅助操作，用于检查是否有一个相关的帮助主题。所有的窗口组件都是 Wi d g e t抽象类的子类。Wi d g e t是HelpHandler 的子类，因为所有的用户界面元素都可有相关的帮助。 (我们也可以使用另一种基于混入类的实现方式 ) 在我们的例子中，按钮是链上的第一个处理者。 B u t t o n类是Wi d g e t类的子类。 Button 构造函数有两个参数: 对包含它的窗口组件的引用和其自身的帮助主题。 B u t t o n版本的H a n d l e H e l

19、 p首先测试检查其自身是否有帮助主题。如果开发者没有定义一个帮助主题，就用 H e l p H a n d l e r中的H a n d l e H e l p操作将该请求转发给它的后继者。如果有帮助主题，那么就显示它，并且搜索结束。 D i a l o g实现了一个类似的策略，只不过它的后继者不是一个窗口组件而是任意的帮助请求处理对象。在我们的应用中这个后继者将是 A p p l i c a t i o n的一个实例。在链的末端是 A p p l i c a t i o n的一个实例。该应用不是一个窗口组件，因此 A p p l i c a t i o n不是 H e l p H a n d

20、 l e r的直接子类。当一个帮助请求传递到这一层时，该应用可提供关于该应用的一般性的信息，或者它可以提供一系列不同的帮助主题。下面的代码创建并连接这些对象。此处的对话框涉及打印，因此这些对象被赋给与打印相关的主题。我们可对链上的任意对象调用 H a n d l e H e l p以触发相应的帮助请求。要从按钮对象开始搜索，只需对它调用H a n d l e H e l p : b u t t o n - H a n d l e H e l p ( ) ;在这种情况下，按钮会立即处理该请求。注意任何 H e l p H a n d l e r类都可作为 D i a l o g的后继者。此外，它

21、的后继者可以被动态地改变。因此不管对话框被用在何处，你都可以得到它正确的与上下文相关的帮助信息。 10. 已知应用许多类库使用职责链模式处理用户事件。对H a n d l e r类它们使用不同的名字，但思想是一样的：当用户点击鼠标或按键盘，一个事件产生并沿链传播。 MacAppApp89 和E T + + W G M 8 8 称之为“事件处理者”，S y m a n t e c的T C L库 S y m 9 3 b 称之为 “B u r e a u c r a t”，而N e X T的A p p K i t命名为“R e s p o n d e r”。图形编辑器框架 U n i d r a w

22、定义了“命令” C o m m a n d对象，它封装了发给 C o m p o n e n t和 C o m p o n e n t Vi e w对象 V L 9 0 的请求。一个构件或构件视图可解释一个命令以进行一个操作，这里“命令”就是请求。这对应于在实现一节中描述的“对象作为请求”的方法。构件和构件视图可以组织为层次式的结构。一个构件或构件视图可将命令解释转发给它的父构件，而父构件依次可将它转发给它的父构件，如此类推，就形成了一个职责链。 E T + +使用职责链来处理图形的更新。当一个图形对象必须更新它的外观的一部分时，调用I n v a l i d a t e R e c t操作。

23、一个图形对象自己不能处理 I n v a l i d a t e R e c t，因为它对它的上下文了解不够。例如，一个图形对象可被包装在一些类似滚动条 ( S c r o l l e r s )或放大器( Z o o m e r s )的对象中，这些对象变换它的坐标系统。那就是说，对象可被滚动或放大以至它有一部分在视区外。因此缺省的I n v a l i d a t e R e c t的实现转发请求给包装的容器对象。转发链中的最后一个对象是一个窗口( Wi n d o w )实例。当窗口收到请求时，保证失效矩形被正确变换。窗口通知窗口系统接口并请求更新，从而处理I n v a l i d a

24、 t e R e c t。 11. 相关模式职责链常与C o m p o s i t e（4 . 3）一起使用。这种情况下，一个构件的父构件可作为它的后继。 5.2 COMMAND（命令）对象行为型模式 1. 意图将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队 或记录请求日志，以及支持可撤消的操作。 2. 别名动作( A c t i o n )，事务( Tr a n s a c t i o n ) 3. 动机有时必须向某对象提交请求，但并不知道关于被请求的操作或请求的接受者的任何信息。例如，用户界面工具箱包括按钮和菜单这样的对象，它们执行请求响应用户输入。但工具箱

25、不能显式的在按钮或菜单中实现该请求，因为只有使用工具箱的应用知道该由哪个对象做哪个操作。而工具箱的设计者无法知道请求的接受者或执行的操作。命令模式通过将请求本身变成一个对象来使工具箱对象可向未指定的应用对象提出请求。这个对象可被存储并像其他的对象一样被传递。这一模式的关键是一个抽象的 C o m m a n d类，它定义了一个执行操作的接口。其最简单的形式是一个抽象的 E x e c u t e操作。具体的 C o m m a n d子类将接收者作为其一个实例变量，并实现 E x e c u t e操作，指定接收者采取的动作。而接收者有执行该请求所需的具体信息。用C o m m a n d对象

26、可很容易的实现菜单（ M e n u），每一菜单中的选项都是一个菜单项（M e n u I t e m）类的实例。一个A p p l i c a t i o n类创建这些菜单和它们的菜单项以及其余的用户界面。该A p p l i c a t i o n类还跟踪用户已打开的 D o c u m e n t对象。该应用为每一个菜单项配置一个具体的 C o m m a n d子类的实例。当用户选择了一个菜单项时，该 M e n u I t e m对象调用它的 C o m m a n d对象的 E x e c u t e方法，而 E x e c u t e执行相应操作。 M e n u I t e m

27、对象并不知道它们使用的是 C o m m a n d的哪一个子类。C o m m a n d子类里存放着请求的接收者，而E x c u t e操作将调用该接收者的一个或多个操作。例如，P a s t e C o m m a n d支持从剪贴板向一个文档 ( D o c u m e n t )粘贴正文。P a s t e C o m m a n d的接收者是一个文档对象，该对象是实例化时提供的。 E x e c u t e操作将调用该 D o c u m e n t的P a s t e操作。而O p e n C o m m a n d的E x e c u t e操作却有所不同：它提示用户输入一个

28、文档名，创建一个相应的文档对象，将其入作为接收者的应用对象中，并打开该文档。有时一个M e n u I t e m需要执行一系列命令。例如，使一个页面按正常大小居中的 M e n u I t e m可由一个C e n t e r D o c u m e n t C o m m a n d对象和一个N o r m a l S i z e C o m m a n d对象构建。因为这种需将多条命令串接起来的情况很常见，我们定义一个 M a c r o C o m m a n d类来让一个 M e n u I t e m执行任意数目的命令。 M a c r o C o m m a n d是一个具体的

29、C o m m a n d子类，它执行一个命令序列。 M a c r o C o m m a n d没有明确的接收者，而序列中的命令各自定义其接收者。请注意这些例子中 C o m m a n d模式是怎样解耦调用操作的对象和具有执行该操作所需信息的那个对象的。这使我们在设计用户界面时拥有很大的灵活性。一个应用如果想让一个菜单与一个按钮代表同一项功能，只需让它们共享相应具体 C o m m a n d子类的同一个实例即可。我们还可以动态地替换 C o m m a n d对象，这可用于实现上下文有关的菜单。我们也可通过将几个命令组成更大的命令的形式来支持命令脚本 (command scriptin

30、g)。所有这些之所以成为可能乃是因为提交一个请求的对象仅需知道如何提交它，而不需知道该请求将会被如何执行。 4. 适用性当你有如下需求时，可使用 C o m m a n d模式： 像上面讨论的 M e n u I t e m对象那样，抽象出待执行的动作以参数化某对象。你可用过程语言中的回调（c a l l b a c k）函数表达这种参数化机制。所谓回调函数是指函数先在某处注册，而它将在稍后某个需要的时候被调用。 C o m m a n d模式是回调机制的一个面向对象的替代品。 在不同的时刻指定、排列和执行请求。一个 C o m m a n d对象可以有一个与初始请求无关的生存期。如果一个请求

31、的接收者可用一种与地址空间无关的方式表达，那么就可将负责该请求的命令对象传送给另一个不同的进程并在那儿实现该请求。 支持取消操作。C o m m a n d的E x c u t e操作可在实施操作前将状态存储起来，在取消操作时这个状态用来消除该操作的影响。 C o m m a n d接口必须添加一个 U n e x e c u t e操作，该操作取消上一次 E x e c u t e调用的效果。执行的命令被存储在一个历史列表中。可通过向后和向前遍历这一列表并分别调用 U n e x e c u t e和E x e c u t e来实现重数不限的“取消”和“重做”。 支持修改日志，这样当系统崩溃

32、时，这些修改可以被重做一遍。在 C o m m a n d接口中添加装载操作和存储操作，可以用来保持变动的一个一致的修改日志。从崩溃中恢复的过程包括从磁盘中重新读入记录下来的命令并用 E x e c u t e操作重新执行它们。 用构建在原语操作上的高层操作构造一个系统。这样一种结构在支持事务( t r a n s a c t i o n )的信息系统中很常见。一个事务封装了对数据的一组变动。 C o m m a n d模式提供了对事务进行建模的方法。 C o m m a n d有一个公共的接口，使得你可以用同一种方式调用所有的事务。同时使用该模式也易于添加新事务以扩展系统。 5. 结构 6.

33、 参与者 C o m m a n d声明执行操作的接口。 C o n c r e t e C o m m a n d ( P a s t e C o m m a n d，O p e n C o m m a n d )将一个接收者对象绑定于一个动作。调用接收者相应的操作，以实现 E x e c u t e。 C l i e n t ( A p p l i c t i o n )创建一个具体命令对象并设定它的接收者。 Invoker ( M e n u I t e m )要求该命令执行这个请求。 R e c e i v e r ( D o c u m e n t，A p p l i c a t i

34、 o n )知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者。 7. 协作 C l i e n t创建一个C o n c r e t e C o m m a n d对象并指定它的R e c e i v e r对象。 某I n v o k e r对象存储该C o n c r e t e C o m m a n d对象。 该I n v o k e r通过调用C o m m a n d对象的E x e c u t e操作来提交一个请求。若该命令是可撤消的， C o n c r e t e C o m m a n d就在执行E x c u t e操作之前存储当前状态以用于取消该命令。

35、ConcreteCommand对象对调用它的R e c e i v e r的一些操作以执行该请求。下图展示了这些对象之间的交互。它说明了 C o m m a n d是如何将调用者和接收者 (以及它执行的请求)解耦的。 8. 效果 C o m m a n d模式有以下效果: 1) Command模式将调用操作的对象与知道如何实现该操作的对象解耦。 2) Command是头等的对象。它们可像其他的对象一样被操纵和扩展。 3) 你可将多个命令装配成一个复合命令。例如是前面描述的 M a c r o C o m m a n d类。一般说来，复合命令是C o m p o s i t e模式的一个实例。

36、4) 增加新的C o m m a n d很容易，因为这无需改变已有的类。 9. 实现实现C o m m a n d模式时须考虑以下问题 : 1) 一个命令对象应达到何种智能程度命令对象的能力可大可小。一个极端是它仅确定一个接收者和执行该请求的动作。另一极端是它自己实现所有功能，根本不需要额外的接收者对象。当需要定义与已有的类无关的命令，当没有合适的接收者，或当一个命令隐式地知道它的接收者时，可以使用后一极端方式。例如，创建另一个应用窗口的命令对象本身可能和任何其他的对象一样有能力创建该窗口。在这两个极端间的情况是命令对象有足够的信息可以动态的找到它们的接收者。 2 )支持取消（u n d o）

37、和重做（r e d o）如果C o m m a n d提供方法逆转( r e v e r s e )它们操作的执行 (例如 U n e x e c u t e或 U n d o操作 )，就可支持取消和重做功能。为达到这个目的， C o n c r e t e C o m m a n d类可能需要存储额外的状态信息。这个状态包括： 接收者对象，它真正执行处理该请求的各操作。 接收者上执行操作的参数。 如果处理请求的操作会改变接收者对象中的某些值，那么这些值也必须先存储起来。接收者还必须提供一些操作，以使该命令可将接收者恢复到它先前的状态。若应用只支持一次取消操作，那么只需存储最近一次被执行的命令

38、。而若要支持多级的取消和重做，就需要有一个已被执行命令的历史表列 (history list)，该表列的最大长度决定了取消和重做的级数。历史表列存储了已被执行的命令序列。向后遍历该表列并逆向执行 ( r e v e r s e - e x e c u t i n g )命令是取消它们的结果；向前遍历并执行命令是重执行它们。有时可能不得不将一个可撤消的命令在它可以被放入历史列表中之前先拷贝下来。这是因为执行原来的请求的命令对象将在稍后执行其他的请求。如果命令的状态在各次调用之间会发生变化，那就必须进行拷贝以区分相同命令的不同调用。例如，一个删除选定对象的删除命令 ( D e l e t e C

39、o m m a n d )在它每次被执行时，必须存储不同的对象集合。因此该删除命令对象在执行后必须被拷贝，并且将该拷贝放入历史表列中。如果该命令的状态在执行时从不改变，则不需要拷贝，而仅需将一个对该命令的引用放入历史表列中。在放入历史表列中之前必须被拷贝的那些 C o m m a n d起着原型（参见 P r o t o t y p e模式（3 . 4）的作用。 3 )避免取消操作过程中的错误积累在实现一个可靠的、能保持原先语义的取消 /重做机制时，可能会遇到滞后影响问题。由于命令重复的执行、取消执行，和重执行的过程可能会积累错误，以至一个应用的状态最终偏离初始值。这就有必要在 C o m m

40、 a n d中存入更多的信息以保证这些对象可被精确地复原成它们的初始状态。这里可使用 M e m e n t o模式（5 . 6）来让该 C o m m a n d访问这些信息而不暴露其他对象的内部信息。 4) 使用C + +模板对( 1 )不能被取消 ( 2 )不需要参数的命令，我们可使用 C + +模板来实现，这样可以避免为每一种动作和接收者都创建一个 C o m m a n d子类。我们将在代码示例一节说明这种做法。 10. 代码示例此处所示的 C + +代码给出了动机一节中的 C o m m a n d类的实现的大致框架。我们将定义 O p e n C o m m a n d、P a

41、s t e C o m m a n d和M a c r o C o m m a n d。首先是抽象的C o m m a n d类： O p e n C o m m a n d打开一个名字由用户指定的文档。注意 O p e n C o m m a n d的构造器需要一个 A p p l i c a t i o n对象作为参数。A s k U s e r是一个提示用户输入要打开的文档名的实现例程。P a s t e C o m m a n d需要一个 D o c u m e n t对象作为其接收者。该接收者将作为一个参数给 P a s t e C o m m a n d的构造器。对于简单的不能取消

42、和不需参数的命令 , 可以用一个类模板来参数化该命令的接收者。我们将为这些命令定义一个模板子类 SimpleCommand. 用R e c e i v e r类型参数化S i m p l e C o m m a n d，并维护一个接收者对象和一个动作之间的绑定 ,而这一动作是用指向一个成员函数的指针存储的。构造器存储接收者和对应实例变量中的动作。 E x e c u t e操作实施接收者的这个动作。为创建一个调用M y c l a s s类的一个实例上的A c t i o n的C o m m a n d对象, 仅需如下代码：记住, 这一方案仅适用于简单命令。更复杂的命令不仅要维护它们的接收者，

43、而且还要登记参数，有时还要保存用于取消操作的状态。此时就需要定义一个 C o m m a n d的子类。 M a c r o C o m m a n d管理一个子命令序列，它提供了增加和删除子命令的操作。这里不需要显式的接收者，因为这些子命令已经定义了它们各自的接收者。 M a c r o C o m m a n d的关键是它的 E x e c u t e成员函数。它遍历所有的子命令并调用其各自的 E x e c u t e操作。注意，如果M a c r o C o m m a n d实现取消操作, 那么它的子命令必须以相对于 E x e c u t e的实现相反的顺序执行各子命令的取消操作。

44、最后, MacroCommand必须提供管理它的子命令的操作。 M a c r o C o m m a n d也负责删除它的子命令。 11. 已知应用可能最早的命令模式的例子出现在 L i e b e r m a n L i e 8 5 的一篇论文中。M a c A p p A p p 8 9 使实现可撤消操作的命令这一说法被普遍接受。而 E T + + W G M 8 8 ，I n t e r Vi e w s L C I + 9 2 ，和 U n i d r a w V L 9 0 也都定义了符合 C o m m a n d模式的类。I n t e r Vi e w s定义了一个A c t

45、 i o n抽象类，它提供命令功能。它还定义了一个 A c t i o n C a l l b a c k模板，这个模板以 A c t i o n方法为参数, 可自动生成C o m m a n d子类。 T H I N K类库 S y m 9 3 b 也使用C o m m a n d模式支持可撤消的操作。 T H I N K中的命令被称为“任务”( Ta s k s )。任务对象沿着一个Chain of Responsiblity（5 . 1）传递以供消费( c o n s u m p t i o n )。 U n i d r a w的命令对象很特别，它的行为就像是一个消息。一个 U n i

46、d r a w命令可被送给另一个对象去解释，而解释的结果因接收的对象而异。此外 , 接收者可以委托另一个对象来进行解释，典型的情况的是委托给一个较大的结构中 (比如在一个职责链中 )接收者的父构件。这样， U n i d r a w命令的接收者是计算出来的而不是预先存储的。 U n i d r a w的解释机制依赖于运行时的类型信息。 C o p l i e n在C + + C o p 9 2 中描述了C + +中怎样实现f u n c t o r s。F u n c t o r s是一种实际上是函数的对象。他通过重载函数调用操作符 (operator( )达到了一定程度的使用透明性。命令模式

47、不同，它着重于维护接收者和函数 (即动作)之间的绑定, 而不仅是维护一个函数。 12. 相关模式 C o m p o s i t e模式（4 . 3）可被用来实现宏命令。 M e m e n t o模式（5 . 6）可用来保持某个状态，命令用这一状态来取消它的效果。在被放入历史表列前必须被拷贝的命令起到一种原型 ( 3 . 4 )的作用。 5.3 INTERPRETER(解释器)类行为型模式 1. 意图给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 2. 动机如果一种特定类型的问题发生的频率足够高 , 那么可能就值得将该问题的各个实例表述为一个

48、简单语言中的句子。这样就可以构建一个解释器 , 该解释器通过解释这些句子来解决该问题。例如，搜索匹配一个模式的字符串是一个常见问题。正则表达式是描述字符串模式的一种标准语言。与其为每一个的模式都构造一个特定的算法，不如使用一种通用的搜索算法来解释执行一个正则表达式，该正则表达式定义了待匹配字符串的集合。解释器模式描述了如何为简单的语言定义一个文法 , 如何在该语言中表示一个句子 , 以及如何解释这些句子。在上面的例子中 , 本设计模式描述了如何为正则表达式定义一个文法 , 如何表示一个特定的正则表达式 , 以及如何解释这个正则表达式。考虑以下文法定义正则表达式 :符号e x p r e s s i o n是开始符号, literal是定义简单字的终结符。解释器模式使用类来表示每一条文法规则。在规则右边的