设计模式（三）

（三）行为型

行为型模式 不同对象之间划分责任和算法的抽象化。

行为型模式分为11种。分别是 模板模式、命令模式、责任链模式、策略模式、迭代器模式。中介者模式、观察者模式、备忘录模式、访问者模式、状态模式和解释器模式。

速记口诀：访问者写好策略备忘录，观察模板迭代的状态，命令中介解释责任链。解释：这句话讲的就是看房子的经过。

看房子的人就是访问者，看房前要写看房策略和备忘录，不能马马虎虎地去看房子。

去看房子的时候，要仔细观察楼板（模板）层叠（迭代）的状态。

看完房子，命令中介解释清楚产权的责任链。

1. 访问者模式

定义：封装了一些作用于数据结构中各元素的操作。目标是：在不改变数据结构的前提下作用于这些元素的操作。

访问者模式对于新添加元素的操作很有作用。

访问者模式涉及以下集中角色。分别是 抽象访问者角色、具体访问者角色、抽象元素、具体元素和结构对象。

(1) 抽象访问者

定义了访问者可以访问哪些元素的具体的访问行为。定义了可以对元素进行哪些操作。一般而言在visit函数中，参数为element。

(2) 具体访问者

实现抽象访问者中各个访问操作。实现对元素的具体操作。一般而言，一个抽象访问者对应多个具体访问者。

(3) 抽象元素

声明一个接受访问者访问的对象。定义元素的逻辑方法。

(4) 具体元素

实现抽象元素中的接受操作。元素定义不同的方法（通过将 抽象访问者 作为参数，使用访问者定义的方法完成自己的元素操作）元素的逻辑方法，由访问者不同，而实现不同的访问

(5) 结构对象

结构对象包含一个元素的容器集合。内部定义遍历方法。调用元素的逻辑操作方法。本质是由访问者实现。

因为由容器，所以元素由添加函数。Add 。同时，函数由定义内部遍历函数。Action

1. add：vector.add
2. Action:

Public action (vector:v){

for(element e:vector){

  e.accept(v)

}

}

遍历结构中的所有元素。

2. 策略模式

体现的是：依赖倒置，依赖的是抽象而非实现。

定义：将算法（策略）封装起来，然后可以切换执行。

本质：依赖抽象而且具体，依赖接口而非实现。

策略模式涉及以下几个角色：抽象策略、具体策略和环境context。

(1) 抽象策略

具体算法的抽象类

(2) 具体策略

算法的一个子类，对抽象方法进行实现。

(3) 环境context

环境是封装一种算法的使用。实现对策略的封装和使用。Strategy 。封装模板的时候，组装的是哪个策略，就会用哪个策略实现。

3. 备忘录模式

定义：不破坏封装的情况下，备份一个对象的内部状态。并在该对象之外保存这个状态。又称之为快照。

备忘录模式涉及以下几个角色。分别是：发起人（被备份的对象）、备忘录（计划备份的属性集合）和负责人（对备忘录进行管理，保存和提供备忘录）。

(1) 发起人

计划被备份的对象角色。发起人创建一个备忘录（指定哪些属性数据备份的范围状态）。同事也可以根据备忘录恢复一个状态。

创建备忘录：createMemento，将发起人的某些内部状态封装成备忘录并返回。由负责人负责调用该方法并保存。

恢复备忘录：接受一个状态的备忘录，将其中的状态恢复到发起人的属性上。该方法也是由负责人调用。

(2) 备忘录：

负责封装发起人的内部状态。在需要的时候提供非发起人进行恢复内部状态。

(3) 负责人

对备忘录进行管理，保存和提供备忘录。

负责人有一个容器列表。保存备忘录。或者 提供备忘录

4. 观察模式

定义：一对多的依赖，一个状态发生变化，所有依赖于它的对象都会接到通知。也称之为订阅模式。

观察者模式涉及以下4个角色。抽象主题、具体主题、抽象观察者和具体观察者。

(1) 抽象主题

主题即为观察者。抽象主题为被观察者的接口定义。

因为被观察者对应的观察者很多，所以，需要一个容器观察者列表。对应观察者列表的操作有：登记一个新的观察者attach、移出列表detach和通知所有观察者

(2) 具体主题

实现抽象主题的接口。

1. 登记观察者：attach
2. 删除登记的观察者：detach
3. 通知观察者：notifyObserver（一般而言。通知观察者是遍历观察者列表，调用各个观察者的update方法）

(3) 抽象观察者

观察者的抽象接口。Update--被观察者发生变化，观察者的相应方法。

(4) 具体观察者

实现观察者接口。Update方法。定义当被观察者发生变化的时候，被观察者通知观察者所调用的方法。

5. 模板模式

体现的是：父类和子类的关系。

定义：定义一个模板。抽取业务逻辑的通用模板。

本质是：对继承的理解和应用。将公用的方法和通用的模板流程放在抽象的父类中。将子类个性个方法定义为抽象方法。在子类中实现。

模板模式涉及两个角色。抽象模板和具体模板。

(1) 抽象模板

抽象模板是一个抽象类。包含以下三部分。

1. 公共方法。
2. 通用的业务流程（模板）
3. 个性的方法（定义为抽象方法，在子类中继承实现）

(2) 具体模板

继承抽象模板，实现其中的抽象方法。

6. 迭代模式

    定义：提供一种方法，访问一个容器中的各个元素。而不暴露该对象内部的细节。

  本质：将遍历的一个容器的各个元素抽象成迭代器。

迭代器涉及以下几个角色；抽象迭代器Iterator、具体迭代器 concrete iterator、抽象聚集aggregate和具体聚集concrete aggregate。

(1) 抽象迭代器iterator

负责定义访问和遍历元素的接口

1. Public boolean HasNext() -- 是否有下一个元素
2. Public void Next() -- 获取下一个元素

(2) 具体迭代器concrete iterator

实现Iterator接口，完成对容器的元素的遍历。

1. 和具体聚集弱关联：对具体聚集有引用（可以通过构造方法传入或者通过set方法设置）

Private concreteAggragate agg

1. 内部属性。Index：当前遍历到的下标和size具体聚集的总数
2. 实现迭代器定义的方法。

// 判断是否有下一个元素

Public boolean hasNext(){

Return index<size

}

// 返回下一个元素

Public void next(){

If(index<size){

Return agg.getElement(index);

}else {

Null;

}

}

(3) 抽象聚集 aggregate

    该角色 提供 创建迭代器的接口。

本质是：一个容器需要创建迭代器。然后才能实现对容器中元素的遍历。

定义 创建迭代器方法

 

// 创建迭代器

Public Iterator createIteretor();

 

// add

Public void add();

(4) 具体聚集 concrete aggregate

创建迭代器。实现抽象聚集的接口。

本质：有一个元素容器。Add，getElement，size和创建迭代器方法。

Private Vector vector = new Vector()

Add (e){

Vector.add(e)

}

Int Size(){

Return vector.size()

}

getElement(int index){

Return vector.get(index)

}

Iterator createIterator(){

Return new concrete_Iteractor(this)

}

7. 状态模式

定义：当内部状态发生变化的时候，行为也发生变化。

状态模式涉及以下几个角色。分别是抽象状态、具体状态和环境Context。

(1) 抽象状态

封装环境的一个特定状态的行为。

封装环境状态和抽象的行为方法。

1. 封装环境：抽象类有环境属性。通过set方法设置环境。为具体状态的公用方法。为的是，抽象行为可能会依赖状态数据。
2. 抽象行为：每个具体的状态都有自己对应的行为。所以，在接口中定义行为的抽象方法。

(2) 具体状态

实现抽象状态接口。实现当前状态的行为方法。

(3) 环境Context

当前属性状态：currentState。作为环境的一个属性，可以通过set设置的方法切换环境中的状态。

方法：

设置当前状态：

setCurrentState(State:state){

CurrentState = state;

}

行为：handle

Handle(){

currentState.handle()

}

8. 命令模式

定义：将调用方法封装起来。解除了发送者和接收者之间的耦合。

命令模式涉及以下几个角色。命令角色、具体命令角色、调用者（执行者）和接收者

(1) 命令角色command

命令的抽象。需要定义一个命令的执行方法execute（所有具体命令需要实现这个执行命令方法）。

一个接口，一个execute方法

(2) 具体命令角色 concrete command

实现命令接口，定义一个接收者，接收者和命令执行之间是弱耦合（接收者是以组合的方式引入）。命令的执行本质上是接收者的执行方法。所以，给每个命令指定那个接收者，就会调用那个接收者的执行方法。

1. 实现命令接口
2. 对接收者receiver弱依赖（通过构造方法传递或者 set 方法引入）。
3. Execute 方法调用receiver的action方法。

(3) 调用者invoker

该角色 负责 调用命令对象的执行 请求。

调用者Invoker 对命令弱依赖。给调用者设置命令，执行者的action方法调用命令的execute方法。

(4) 接收者 receiver

该角色负责具体实施和执行一个请求。定义一种执行方法。命令生成时需要指定处理方式。

9. 中介者模式

定义：用一个中介对象封装一系列对象之间的交互。

中介者模式涉及以下几个角色。抽象中介角色、具体中介角色、抽象同事角色和具体同时角色。

核心：本来是同事到同事之间的交互。通过中介者分成了两部分。同事到中介者的方法（中介者的定义）和中介到同事之间的方法（同事的定义）。比如：两类同事A和B之间的交互，中介者就若关联这两类依赖的同事。

(1) 抽象中介角色mediator

同事到中介平台的统一接口（一般包含两类接口：注册接口和中介业务逻辑方法）

(2) 具体中介角色

同事和中介平台的交互（本质是同事角色之间的交互行为（包含注册、业务逻辑方法））。

同事容器：根据同事的分类，在注册方法中将同事添加到对应的同事容器中去。

注册方法：同事在进行业务逻辑之前，需要注册到平台。之后业务逻辑才能找到彼此

业务逻辑方法：定义业务逻辑方法。是为了同事执行业务逻辑时候调用。将同事之间的交互变成平台的方法。

(3) 抽象同事角色

中介者到同事对象的接口。

同事弱关联中介。

(4) 具体同事角色

依赖平台 mediator。

同事的业务逻辑方法调用  中介平台的 mediator.业务逻辑方法

同事的注册/构造方法调用 中介平台的 mediator.注册方法

10. 解释器模式

11. 责任链模式

定义：为请求创建一个接受对象的链。其中每个对象都可能处理这个请求。同时每个对象都有一个当前对象的引用。从而将多个接受对象组成链

本质：通过责任链的设计，请求按照责任链的顺序依次匹配执行。和switch case 是类似的处理。

责任链模式涉及两个角色。抽象处理角色Handler和具体处理角色concrete handler。

(1) 抽象处理角色

该角色对处理进行抽象。

1. 定义抽象方法。--或者处理，或者返回处理的下一个处理者的引用。
2. 对处理者的依赖。包含Handler属性，通过set的方式，引入。为弱关联。

(2) 具体处理角色

继承抽象类 抽象处理角色，实现抽象方法。

2020年8月25日星期二