设计模式总结(2)

内容简介：设计模式总结(2)

本文是 设计模式 总结的第二篇：主要详细讲解了行为型设计模式，希望对大家有所帮助。

行为型设计模式：

Chain Of Responsibility Parttert（职责链模式）

意图

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

适用性

1. 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

2. 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

3. 可处理一个请求的对象集合应被动态指定。

结构

* Handler

定义一个处理请求的接口。

(可选) 实现后继链。

* ConcreteHandler

处理它所负责的请求。

可访问它的后继者。

如果可处理该请求,就处理之;否则将该请求转发给它的后继者。

* Client

向链上的具体处理者(ConcreteHandler)对象提交请求。

例子

Command Pattern（命令模式）

别名：动作(Action)，事务(Transaction)

意图

将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队。

适用性

1. 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。

2. 系统需要在不同的时间指定请求、将请求排队和执行请求。

3. 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。

4. 系统需要将一组操作组合在一起，即支持宏命令。

结构

角色如下：

Command：

定义命令的接口，声明执行的方法。

ConcreteCommand：

命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。

Receiver：

接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。

Invoker：

要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。

Client：

创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在组装命令对象和接收者，或许，把这个Client称为装配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。

例子

有撤销功能的命令：

优缺点

> 优点

1.降低对象之间的耦合度。

2.新的命令可以很容易地加入到系统中。

3.可以比较容易地设计一个组合命令。

4.调用同一方法实现不同的功能

> 缺点

使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个命令都需要设计一个具体命令类，因此某些系统可能需要大量具体命令类，这将影响命令模式的使用。

Interpreter Pattern（解释器模式）

意图

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

结构

模式所涉及的角色如下所示：

（1）抽象表达式(Expression)角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称做解释操作。

（2）终结符表达式(Terminal Expression)角色：实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。

（3）非终结符表达式(Nonterminal Expression)角色：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+"就是非终结符，解析“+”的解释器就是一个非终结符表达式。

（4）环境(Context)角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

适用性

当有一个语言需要解释执行 , 并且你可将该语言中的句子表示为一个抽象语法树时,可使用解释器模式。而当存在以下情况时该模式效果最好:

* 该文法简单对于复杂的文法 , 文法的类层次变得庞大而无法管理。此时语法分析程序生 ?成器这样的 工具 是更好的选择。它们无需构建抽象语法树即可解释表达式 , 这样可以节 省空间而且还可能节省时间。 ?

* 效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的 , 而是 ?首先将它们转换成另一种形式。例如,正则表达式通常被转换成状态机。但即使在这种 情况下, 转换器仍可用解释器模式实现, 该模式仍是有用的。 ?

例子

SQL语句解析

XML/JSON解析

编程语言的编译器

正则表达式

…

优缺点

> 优点：

(1)易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。

(2)每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。

(3)实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。

(4)增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

> 缺点：

(1)对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。

(2)执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

Iterator Pattern（迭代器模式）

意图

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

适用性

1. 访问一个聚合对象的内容而无需暴露它的内部表示。

2. 支持对聚合对象的多种遍历。

3. 为遍历不同的聚合结构提供一个统一的接口（即, 支持多态迭代）。

结构

参与者：

* Iterator（迭代器）

迭代器定义访问和遍历元素的接口。

* ConcreteIterator （具体迭代器）

具体迭代器实现迭代器接口。

对该聚合遍历时跟踪当前位置。

* Aggregate （聚合）

聚合定义创建相应迭代器对象的接口。

* ConcreteAggregate （具体聚合）

具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。

例子

编程语言级别已经提供，如：数组、集合、foreach循环。

Mediator Pattern（中介者模式）

意图

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

适用性

* 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。

* 一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。

* 想定制一个分布在多个类中的行为，而又不想生成太多的子类。

结构

参与者：

Mediator(中介者)

中介者定义一个接口用于与各同事( Colleague)对象通信。

ConcreteMediator(具体中介者)

— 具体中介者通过协调各同事对象实现协作行为。

— 了解并维护它的各个同事。

Colleague class(同事类)

— 每一个同事类都知道它的中介者对象。

— 每一个同事对象在需与其他的同事通信的时候,与它的中介者通信。

例子

优缺点

> 优点：

中介者模式的优点就是减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。

> 缺点：

中介者模式的缺点就是中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

Mememto Pattern（备忘录模式）

意图

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

适用性

* 必须保存一个对象在某一个时刻的(部分)状态, 这样以后需要时它才能恢复到先前的状态。

* 如果一个用接口来让其它对象直接得到这些状态，将会暴露对象的实现细节并破坏对象的封装性。

结构

涉及角色：

* Originator(发起人)：负责创建一个备忘录Memento，用以记录当前时刻自身的内部状态，并可使用备忘录恢复内部状态。Originator可以根据需要决定Memento存储自己的哪些内部状态。

* Memento(备忘录)：负责存储Originator对象的内部状态，并可以防止Originator以外 的其他对象访问备忘录。备忘录有两个接口：Caretaker只能看到备忘录的窄接口，他只能将备忘录传递给其他对象。Originator却可看到备忘 录的宽接口，允许它访问返回到先前状态所需要的所有数据。

* Caretaker(管理者)：负责备忘录Memento，不能对Memento的内容进行访问或者操作。

例子

以保存游戏进度为例，在游戏角色大战Boss前将该角色的状态存储，与Boss作战后角色的各项能力会下降，如果没有通关，则可利用备忘录进行恢复到战前状态。

优缺点

> 优点：

1、有时一些发起人对象的内部信息必须保存在发起人对象以外的地方，但是必须要由发起人对象自己读取，这时，

使用备忘录模式可以把复杂的发起人内部信息对其他的对象屏蔽起来，从而可以恰当地保持封装的边界。

2、本模式简化了发起人类。发起人不再需要管理和保存其内部状态的一个个版本，客户端可以自行管理他们所需

要的这些状态的版本。

> 缺点：

1、如果发起人角色的状态需要完整地存储到备忘录对象中，那么在资源消耗上面备忘录对象会很昂贵。

2、当负责人角色将一个备忘录 存储起来的时候，负责人可能并不知道这个状态会占用多大的存储空间，从而无法提醒用户一个操作是否很昂贵。

3、当发起人角色的状态改变的时候，有可能这个协议无效。如果状态改变的成功率不高的话，不如采取“假如”协议模式。

Observer Pattern（观察者模式）

意图

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

适用性

* 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

* 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

* 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之，你不希望这些对象是紧密耦合的。

结构

参与者

* Subject(目标)

— 目标知道它的观察者。可以有任意多个观察者观察同一个目标。

— 提供注册和删除观察者对象的接口。 ? Observer(观察者)

— 为那些在目标发生改变时需获得通知的对象定义一个更新接口。

* ConcreteSubject(具体目标)

— 将有关状态存入各ConcreteObserver对象。

— 当它的状态发生改变时 , 向它的各个观察者发出通知。

* ConcreteObserver(具体观察者)

— 维护一个指向ConcreteSubject对象的引用。— 存储有关状态,这些状态应与目标的状态保持一致。— 实现Observer的更新接口以使自身状态与目标的状态保持一致。

例子

State Pattern（状态模式）

意图

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

适用性

* 一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为。

* 一个操作中含有 庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常, 有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一 对象可以不依赖于其他对象而独立变化。

结构

参与者：

* Context(环境角色)

— 定义客户感兴趣的接口。

— 维护一个ConcreteState子类的实例,这个实例定义当前状态。

* State(抽象状态角色)

— 定义一个接口以封装与 Context的一个特定状态相关的行为。

* ConcreteState subclasses(具体状态角色)

— 每一子类实现一个与Context的一个状态相关的行为。

例子

优缺点

> 优点：

1. 结构清晰

避免了过多的switch...case或者if...else语句的使用，避免了程序的复杂性，提高系统的可维护性。

2. 遵循设计原则

很好地体现了开闭原则和单一职责原则，每个状态都是一个子类，你要增加状态就要增加子类，你要修改状态，你只修改一个子类就可以了。

3. 封装性非常好

这也是状态模式的基本要求，状态变换放置到类的内部来实现，外部的调用不用知道类内部如何实现状态和行为的变换。

> 缺点：

子类会太多，类膨胀。

> 注意事项：

状态模式适用于当某个对象在它的状态发生改变时，它的行为也随着发生比较大的变化，也就是说在行为受状态约束的情况下可以使用状态模式，而且使用时对象的状态最好不要超过5个。

Strategy Pattern（策略模式）

意图

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

适用性

1. 许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

2. 需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间/时间权衡的算法。当这些变体实现为一个算法的类层次时，可以使用策略模式。

3. 算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

4. 一个类定义了多种行为, 并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

结构

参与者：

> Strategy(策略)

— 定义所有支持的算法的公共接口。Context使用这个接口来调用某 ConcreteStrategy定 义的算法。

> ConcreteStrategy(具体策略)

— 以Strategy接口实现某具体算法。

> Context(上下文)?

— 用一个ConcreteStrategy对象来配置。

— 维护一个对Strategy对象的引用。

— 可定义一个接口来让Stategy访问它的数据。

例子

优缺点

> 优点：

* 算法可以自由切换

这是策略模式本身定义的，只要实现抽象策略，它就成为策略家族的一个成员，通过封装角色对其进行封装，保证对外提供“可自由切换”的策略。

* 避免使用多重条件判断

如果没有策略模式，我们想想看会是什么样子？一个策略家族有5个策略算法，一会要使用A策略，一会要使用B策略，怎么设计呢？使用多重的条件语句？多重条件语句不易维护，而且出错的概率大大增强。使用策略模式后，可以由其他模块决定采用何种策略，策略家族对外提供的访问接口就是封装类，简化了操作，同时避免了条件语句判断。

* 扩展性良好

这甚至都不用说是它的优点，因为它太明显了。在现有的系统中增加一个策略太容易了，只要实现接口就可以了，其他都不用修改，类似于一个可反复拆卸的插件，这大大地符合了OCP原则。

> 缺点：

* 策略类数量增多

每一个策略都是一个类，复用的可能性很小，类数量增多。

* 所有的策略类都需要对外暴露

上层模块必须知道有哪些策略，然后才能决定使用哪一个策略，这与迪米特法则是相违背的，我只是想使用了一个策略，我凭什么就要了解这个策略呢？那要你的封装类还有什么意义？这是原装策略模式的一个缺点，幸运的是，我们可以使用其他模式来修正这个缺陷，如工厂方法模式、代理模式或享元模式。

TemplateMethod Pattern（模版方法模式）

意图

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

适用性

* 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

* 各子类中公共的 行为应被提取出来并集中到一个公共父类中以避免代码重复。这是Opdyke和Johnson所描述过的“重分解以一般化”的一个很好的例子。首先识别现有 代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。

* 控制子类扩展。模板方法只在特定点调用“hook”操作，这样就只允许在这些点进行扩展。

结构

参与者：

* AbstractClass(抽象类,如Application)

— 定义抽象的原语操作(primitive operation),具体的子类将重定义它们以实现一个算法的各步骤。

— 实现一个模板方法 ,定义一个算法的骨架。该模板方法不仅调用原语操作,也调用定义 在AbstractClass或其他对象中的操作。

* ConcreteClass(具体类,如MyApplication)

— 实现原语操作以完成算法中与特定子类相关的步骤。

例子

优缺点

> 优点：

1. 封装不变部分，扩展可变部分

把认为是不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展。在悍马模型例子中，是不是就非常容易扩展？例如增加一个H3型号的悍马模型，很容易呀，增加一个子类，实现父类的基本方法就可以了。

2. 提取公共部分代码，便于维护

我们例子中刚刚走过的弯路就是最好的证明，如果我们不抽取到父类中，任由这种散乱的代码发生，想想后果是什么样子？维护人员为了修正一个缺陷，需要到处查找类似的代码！

3. 行为由父类控制，子类实现

基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。

> 缺点：

按照我们的设计习惯，抽象类负责声明最抽象、最一般的事物属性和方法，实现类完成具体的事物属性和方法。但是模板方法模式却颠倒了，抽象类定义了部分抽象方法，由子类实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响，这在复杂的项目中，会带来代码阅读的难度，而且也会让新手产生不适感。

Visitor Pattern（访问者模式）

意图

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

适用性

* 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。

* 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。Visitor使得你可以将相关的操作集中起来定义在一个类中。当该对象结构被很多应用共享时，用Visitor模式让每个应用仅包含需要用到的操作。

* 定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。

总结一下，在这种地方你一定要考虑使用访问者模式：业务规则要求遍历多个不同的对象。这本身也是访问者模式出发点，迭代器模式只能访问同类或同接口的数据（当然了，如果你使用instanceof，那么能访问所有的数据，这没有争论），而访问者模式是对迭代器模式的扩充，可以遍历不同的对象，然后执行不同的操作，也就是针对访问的对象不同，执行不同的操作。

结构

参与者：

Visitor(访问者)

— 为该对象结构中 ConcreteElement的每一个类声明一个 Visit操作。该操作的名字和特 征标识了发送 Visit请求给该访问者的那个类。这使得访问者可以确定正被访问元素 的具体的类。这样访问者就可以通过该元素的特定接口直接访问它。

ConcreteVisitor(具体访问者)

— 实现每个由 Visitor声明的操作。每个操作实现本算法的一部分,而该算法片断乃是对应于结构中对象的类。ConcreteVisitor为该算法提供了上下文并存储它的局部状态。这一状态常常在遍历该结构的过程中累积结果。 ? Element(元素,如Node)

— 定义一个Accept操作,它以一个访问者为参数。

ConcreteElement(具体元素)

— 实现Accept操作,该操作以一个访问者为参数。

ObjectStructure(对象结构)

— 能枚举它的元素。

— 可以提供一个高层的接口以允许该访问者访问它的元素。

— 可以是一个复合(参见Composite组合模式)或是一个集合,如一个列表或一个无序集合。

例子

另一个例子：

优缺点

> 优点：

1. 访问者模式使得易于增加新的操作 访问者使得增加依赖于复杂对象结构的构件的操作变得容易了。仅需增加一个新的访问者即可在一个对象结构上定义一个新的操作。相反, 如果每个功能都分散在多个类之上的话,定义新的操作时必须修改每一类。

2. 访问者集中相关的操作而分离无关的操作 相关的行为不是分布在定义该对象结构的 各个类上,而是集中在一个访问者中。无关行为却被分别放在它们各自的访问者子类中。这 就既简化了这些元素的类,也简化了在这些访问者中定义的算法。所有与它的算法相关的数 据结构都可以被隐藏在访问者中。

> 缺点：

1. 增加新的 ConcreteElement类很困难

Visitor模式使得难以增加新的 Element的子类。每 添加一个新的 ConcreteElement都要在 Vistor中添加一个新的抽象操作,并在每一个 ConcretVisitor类中实现相应的操作。有时可以在 Visitor中提供一个缺省的实现,这一实现可 以被大多数的 ConcreteVisitor继承,但这与其说是一个规律还不如说是一种例外。

所以在应用访问者模式时考虑关键的问题是系统的哪个部分会经常变化,是作用于对象结构上的算法呢还是构成该结构的各个对象的类。如果老是有新的 ConcretElement类加入进来的话, Vistor类层次将变得难以维护。在这种情况下,直接在构成该结构的类中定义这些操作可能更容易一些。如果 Element类层次是稳定的,而你不断地增加操作获修改算法,访问者模式可以帮助你管理这些改动。

2. 破坏封装

访问者方法假定ConcreteElement接口的功能足够强,足以让访问者进行它 们的工作。结果是,该模式常常迫使你提供访问元素内部状态的公共操作,这可能会破坏它 的封装性。

以上所述就是小编给大家介绍的《设计模式总结(2)》，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持！

查看所有标签

猜你喜欢:

• 设计模式——订阅模式（观察者模式）
• 设计模式-简单工厂、工厂方法模式、抽象工厂模式
• java23种设计模式-门面模式（外观模式）
• 设计模式-享元设计模式
• Java 设计模式之工厂方法模式与抽象工厂模式
• JAVA设计模式之模板方法模式和建造者模式

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。