Contents
  1. 1. Behavioral Patterns
  2. 2. Chain of Responsibility
    1. 2.1. What
    2. 2.2. Why
    3. 2.3. Solution
    4. 2.4. Consequences
  3. 3. Command
    1. 3.1. What
    2. 3.2. Why
    3. 3.3. Solution
    4. 3.4. Consequences
  4. 4. Interpreter
    1. 4.1. What
    2. 4.2. Why
    3. 4.3. Solution
    4. 4.4. Consequences
  5. 5. Iterator
    1. 5.1. What
    2. 5.2. Why
    3. 5.3. Solution
    4. 5.4. Consequences
  6. 6. Mediator
    1. 6.1. What
    2. 6.2. Why
    3. 6.3. Solution
    4. 6.4. Consequences
  7. 7. Memento
    1. 7.1. What
    2. 7.2. Why
    3. 7.3. Solution
    4. 7.4. Consequences
  8. 8. Observer
    1. 8.1. What
    2. 8.2. Why
    3. 8.3. Solution
    4. 8.4. Consequences
  9. 9. State
    1. 9.1. What
    2. 9.2. Why
    3. 9.3. Solution
    4. 9.4. Consequences
  10. 10. Strategy
    1. 10.1. What
    2. 10.2. Why
    3. 10.3. Solution
    4. 10.4. Consequences
  11. 11. Template Method
    1. 11.1. What
    2. 11.2. Why
    3. 11.3. Solution
    4. 11.4. Consequences
  12. 12. Visitor
    1. 12.1. What
    2. 12.2. Why
    3. 12.3. Solution
    4. 12.4. Consequences
  13. 13. References

本篇将介绍设计模式中常见的11种行为型模式,其中设计模式的实现代码使用 Java 语言描述。

Behavioral Patterns

行为型模式它关注对象之间的算法和职责分配。它不仅是描述对象和类的模式,也是描述它们之间交流的模式。

Chain of Responsibility

What

通过给多个对象处理请求的机会,避免耦合请求发送者与接收者。Chain 接收请求,并沿着 chain 传递请求直到有一个对象能够处理该请求为止。

Why

Motivation

避免将请求者与具体的接收者绑定。使用一个类统一接收所有请求,接收者连接成一条链来处理请求。

Applicability

  • 超过一个对象去处理请求。
  • 你想发送一个请求给一些对象中的一个,并且不明确指定接收者。
  • 动态指定一组对象处理一个请求。

Solution

Structure

类结构

对象结构

Participants

  • Handler:定义一个接口去处理请求。
  • ConcreteHandler:处理请求。接收继任者(successor)。如果它能处理一个请求,则处理它;如果不能,则将这个请求转发给它的继任者。
  • Client:初始化一个请求,发送给 chain 上的一个 ConcreteHandler 对象。

Collaborations

  • 当 Client 发送一个请求,这个请求在 Chain 上传播,直到有一个 ConcreteHandler 对象能够处理它。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public abstract class Handler{
private Handler nextHandler;

public abstract void handleRequest();

public void setNext(Handler handler){
this.nextHandler = handler;
}
}

public class ConcreteHandler1 extends Handler{
public void handleRequest(int request){
if (request == 1){
System.out.println("handle by ConcreteHandler1");
}else{
if (nextHandler != null)
nextHandler.process(request);
}
}
}

public class ConcreteHandler2 extends Handler{
public void handleRequest(int request){
if (request == 2){
System.out.println("handle by ConcreteHandler2");
}else{
if (nextHandler != null)
nextHandler.process(request);
}
}
}

public class Client{
public static void main(String[] args){
Handler handler = new ConcreteHandler1();
Handler nextHandler = new ConcreteHandler2();
handler.setNext(nextHandler);
int request1 = 1, request2 = 2;
handler.handleRequest(request1);
handler.handleRequest(request2);
}
}

Consequences

Benefits

  • 减少了耦合。
  • 增加了给对象分配职责的灵活性。

Drawbacks

  • 请求的接收不能保证。因为一个请求没有明确指定接收者,所有不能保证它能被处理。

Command

What

将一个请求封装为一个对象,因此让你参数化客户端的不同请求。

Why

Motivation

有时需要发送一个请求给对象,但不知道任何关于请求的操作或者请求的接收者。

Applicability

  • 参数化执行动作,将其封装为对象。
  • 在不同的时间指定,排队和执行请求。Command 对象的生命周期可以独立于原始请求。
  • 支持 undo。Command 执行操作可以存储状态用来反转影响 command 本身。
  • 支持 logging changes。所以可以在系统崩溃后可以重新正确运行。
  • 围绕基于 primitive 操作的 high-level 操作来构建系统。

Solution

Structure

Participants

  • Command:声明用于执行操作的接口。
  • ConcreteCommand:定义 Receiver object 和 action 之间的绑定。通过调用接收者相应的操作来实现 Execute。
  • Cient:创建一个 ConcreteCommnd 对象,以及设置它的 receiver。
  • Invoker:请求 command 得到请求结果。
  • Receiver:知道如何执行与请求相关的操作。

Collaborations

  • Client 创建一个 ConcreteCommand 以及指定它的 receiver。
  • Invoker 对象存储 ConcreteCommand 对象。
  • Invoker 通过调用 command 对象的 execute() 方法来发出请求。
  • ConcreteCommand 对象调用接收者的操作来完成请求。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public interface Command{
void execute();
}
public class Receiver{
public void action1(){
System.out.println("action 1 executing...");
}
public void action2(){
System.out.println("action 2 executing...");
}
}
public class ConcreteCommand1 implements Command{
public Receiver receiver;
public ConcreteCommand1(Receiver receiver){
this.receiver = receiver;
}
public void execute(){
receiver.action1();
}
}
public class ConcreteCommand2 implements Command{
public Receiver receiver;
public ConcreteCommand1(Receiver receiver){
this.receiver = receiver;
}
public void execute(){
receiver.action2();
}
}
public class Invoker{
Command slot;
public void setCommand(Command command){
this.slot = command;
}
public void requestExecute(){
this.slot.execute();
}
}
public class Clinet{
Invoker invoker = new Invoker();
Receiver receiver = new Receiver();
invoker.setCommnad(new ConcreteComand1(receiver));
invoker.requestExecute();
invoker.setCommnad(new ConcreteComand2(receiver));
invoker.requestExecute();
}

Consequences

Benefits

  • Command 将调用操作的对象与知道如何执行该操作的对象分离。
  • 你可以装配命令作为 composite 命令。
  • 很容易添加新的 Command。因为你不需要该改变存在的 classes。

Interpreter

What

给定一种语言,定义其语法表示形式,以及使用该表示形式来解释语言中的句子。

Why

Motivation

如果一个种特殊的问题经常发生,它可能值得用简单的语言将问题的实例表达为句子。然后,你可以构建 interpreter 通过解释这些句子来解决问题。

Applicability

  • 语法是简单的。
  • 效率不是一个关键问题。

Solution

Structure

Participants

  • AbstractExpression:定义一个抽象 interpret 操作,它存在于所有 abstract syntax tree 中的节点。
  • TerminalExpression:实现与 terminal symbols 有关的 interpret 操作。
  • NonterminalExpression:实现 nonterminal symbols 相关的 interpret 操作。
  • Context:包含给 interpreter 的全部信息。
  • Client:构建一个抽象的 syntax tree 表示一个符合语法规定的特定的句子。调用 interpret 操作。

Collaborations

  • Client 构建一个句子作为 NonterminalExpression 和 TerminalExpression 实例的abstract syntax tree 。然后,client 初始化 context,调用 interpret 操作。
  • 每个 NonterminalExpression node 定义了 interpret 对每个子表达式上的 interpret。
  • 每个 node 的 interpret 操作使用 context 去存储和访问 interpreter 的状态。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public interface Expression{
boolean interpret(String context);
}

public class TerminalExpression implements AbstractExpression{
private String data;
public TerminalExpression(String data){
this.data = data;
}
public boolean interpret(Context context){
if (data.contains(Context.data)){
return true;
}else{
return false;
}
}
}
public class NonterminalExpression implements AbstractExpression{
private Expression expression1;
private Expression expression2;
public NonterminalExpression(Expression expression1, Expression expression2){
this.expression1 = expression1;
this.expression2 = expression2;
}
public boolean interpret(Context context){
return expression1.interpret(context) && expression2.interpret(context);
}
}
public class Context{
private String data;
public Context(String data){
this.data = data;
}
}

public class Client{
Context context1 = new Context("Tom");
TerminalExpression terminalExp1 = new TerminalExpression("Tom");
TerminalExpression terminalExp2 = new TerminalExpression("Jack");
terminalExp1.interpret(context1);
terminalExp2.interpret(context1);
NonterminalExpression nonterminalExp = new NonterminalExpression(terminalExp1, terminalExp2);
nonterminalExp.interpret(context1);
}

Consequences

Benefits

  • 它很容易去改变和扩展语法。
  • 实现语法是容易的。
  • 可以增加新的方式去 interpret 表达式。

Drawbacks

  • 复杂的语法很难去管理和维护。

Iterator

What

提供以一种方法去顺序地访问聚合对象的元素,而不暴露它的底层表示。

Why

Motivation

一个聚合对象如 list,应该有一种方式去访问它的元素而不暴露它的内部结构。你可能想要用不同的方式去遍历集合,让它取决于你想要的实现。Iterator 模式可以帮你实现以上功能。

Applicability

  • 访问一个聚合对象的内容,而不暴露它的内部表示。
  • 支持多种对聚合对象的遍历方式。
  • 提供统一的接口去遍历不同类型的聚合数据结构。

Solution

Structure

Participants

  • Iterator:定义一个接口去访问和遍历元素。
  • ConcreteIterator:实现 Iterator 接口。保持追踪遍历聚合元素的位置。
  • Aggregate:定义创建 Iterator 对象的接口。
  • ConcreteAggregate:实现创建 Iterator 对象接口,返回合适的 ConcreteIterator 对象。

Collaborations

  • ConcreteIterator 保持聚合元素对象的轨迹,能够计算在遍历中接下的元素对象。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public interface Aggregate{
Iterator createIterator();
}
public class ConcreteAggregate implements Aggregate{
private int[] data = new int[32];
private int size;
private int currentSize;

public void add(int number){
data[currentSize] = number;
currentSize++;
}

public Iterator createIterator(){
return new ConcreteIterator(data, currentSize);
}
}

public interface Iterator{
int first();
void next();
boolean isDone();
int currentItem();
}
public class ConcreteIterator implements Iterator{
private int[] data;
private int cursor = 0;

public ConcreteIterator(int[] data, int currentSize){
data = new int[currentSize];
for (int i = 0; i < currentSize; i++){
this.data[i] = data[i];
}
}

public int first(){
// ignored. not important
return null;
}
public int next(){
if (cursor < data.length){
return data[cursor++];
}else{
throw new ArrayIndexOutOfBoundExcpetion();
}
}
public boolean isDone(){
return cursor >= data.length -1;
}
public int currentItem(){
// ignored. not important
return null;
}
}

public class Client{
public static void main(String[] args){
Aggregate aggregate = new ConcreteAggregate();
aggregate.add(1);
Iterator iterator = aggregate.createIterator();
while(! iterator.isDone()){
System.out.println(iterator.next());
}
}
}

Consequences

Benefits

  • 它支持聚合结构的遍历中的变化。
  • Iterator 简化了 Aggregate 接口。
  • 一个聚合对象可以有多个遍历。

Mediator

What

定义一个对象去封装一组对象是如何交互。Mediator 通过防止对象之间显式地互相引用来促进松耦合,并且它让你可以独立地更改它们之间的交互。

Why

Motivation

面向对象的设计鼓励在对象之间分配行为。这种分配可能导致一个对象与很多对象有关联。大量的相互连接让系统的行为很难去改变。你可以使用 Mediator 去解决这类问题。Mediator 可以用来控制和协调一组对象之间的交互。Mediator 充当了中介,可以防止一组对象明确地相互引用。对象只知道 Mediator,从而减少对象相互连接的数量。

Applicability

  • 一组对象交流十分复杂。
  • 重用一个对象是复杂的,因为它引用了很多其他的类,以及与很多其他类存在交流。
  • 在多个类之间分布的行为应可自定义,而无需大量子类化。

Solution

Structure

类结构

对象结构

Participants

  • Mediator:为 Colleague 对象交流定义一个接口。
  • ConcreteMediator:通过协调 Colleague 对象来实现合作行为。维护它的 colleagues 对象。
  • Colleague classes:每一个 Collegue 类知道它的 Mediator 对象。每个 colleague 与它的 mediator 交流。

Collaborations

  • Colleagues 发送和接收请求来自 Mediator 对象。Mediator 通过在适当的 Colleagues 之间路由请求来实现协作行为。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public interface Mediator{

}
public class ConcreteMediator implements Mediator{
private ConcreteColleague1 concreteColleague1;
private ConcreteColleague2 concreteColleague2;
public void setConcreteColleague1(ConcreteColleague1 concreteColleague1){
this.concreteColleague1 = concreteColleague1;
}
public void setConcreteColleague2(ConcreteColleague2 concreteColleague2){
this.concreteColleague2 = concreteColleague2;
}
public void callHelloToColleague2FromColleague1(){
concreteColleague2.hello(concreteColleague1);
}
}
public interface Colleague{

}
public class ConcreteColleague1 implements Colleague{
private Mediator mediator;
public ConcreteColleague1(){}
public ConcreteColleague1(Mediator mediator){
this.mediator = mediator;
}
public void sayHelloToColleague2(){
mediator.sayHelloToColleague2FromColleague1();
}
}
public class ConcreteColleague2 implements Colleague{
private Mediator mediator;
public ConcreteColleague2(){}
public ConcreteColleague2(Mediator mediator){
this.mediator = mediator;
}
public void hello(Colleague colleague){
System.out.println("hello, response to " + colleague);
}
}
public class Client{
public static void main(String[] args){
// config mediator
Mediator mediator = new ConcreteMediator();
ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
mediator.setConcreteColleague1(colleague1);
mediator.setConcreteColleague2(colleague2);
// send request among colleagues by call mediator methods
colleague1.sayHelloToColleague2();
}
}

Consequences

Benefits

  • 它限制了子类。
  • 它解耦了 colleagues。
  • 它简化对象通信协议。
  • 它将对象的协作抽象化。
  • 它中心控制对象的交互。

Drawbacks

  • 由于它中心控制对象的交互,Mediator 会变得很庞大,它自身变得很难维护。

Memento

What

在不违反封装和外部化一个对象的内部状态等情况下,使得该对象可以在以后恢复之前的状态。

Why

Motivation

有时需要记录一个对象的内部状态。实现检查点和 undo 功能,让用户在发生错误时恢复状态记录的对象状态。但是对象一般是封装了一些或全部状态,使它不能被其他对象访问,以及不可能在外部保存。暴露对象的内部状态违反了封装,这会损害应用程序的可靠性和可扩展性。

我们可以使用 Memento 模式解决这个问题。memento 是一个对象,它可以存储对象内部状态的快照(snapshot)。

Applicability

  • 一个对象的状态的快照必须保存,因此它可以在以后恢复之前的状态。
  • 一个接口直接地获取状态将暴露实现细节和打破对象的封装。

Solution

Structure

Participants

  • Memento:1)存储 originator 对象的内部状态。2)防止非 originator 对象访问。3)它是一个 POJO 类。
  • Originator:1)创建一个 包含当前内部状态快照的 memento。2)使用 memento 去恢复它的内部状态。
  • Caretaker:1)负责 memento 的保管。2)不操作或检查 memento 的内容。3)保持多个 memento 的轨迹,维护保存点。

Collaborations

  • caretaker 从 originator 请求一个 memento,保持一段时间,以及把它传回 originator。它们的交互如下图所示。
  • Memento 是被动的。只有 orginator 能够创建 memento 指派或取回它的状态。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public class Memento{
private int state;

public Memento(){}
public Memento(int state){
this.state = state;
}
public int getState(){
return state;
}
public void setState(int state){
this.state = state;
}
}
public class Originator{
private int state;
public void setState(int state){
this.state = state;
}
public int getState(){
return this.state;
}
public void createMemento(){
return new Memento(this.state);
}
public setMemento(Memento memento){
this.state = memento.getState();
}
}
pubilc class Caretaker{
private List<Memento> mementos = new ArrayList<>();
private Originatro orginator;
public Caretacker(Originator orginator){
this.originator = orginator;
}
pubilc void addMemento(){
Memento newMemento = this.originator.createMemento();
this.mementos.add(newMemento);
return newMemento;
}
public void setMemento(Memento memento){
for (m : mementos){
if (m.state == memento.state){
this.originator.setMementor(m);
}
}
}
}

public class Client{
public static void main(String[] args){
Originatro originator = new Originator();
Careracker caretacker = new Caretacker(originator);
originator.setState(1);
System.out.println("state one: " + originator.getState());
Memento memento1 = caretacker.addMemento();
originator.setState(2);
System.out.println("state two: " + originator.getState());
Memento memento2 = caretacker.addMemento();
caretacker.setMemento(memento1);
System.out.println("restore state one: " + originator.getState());
}
}

Consequences

Benefits

  • 保持封装边界。
  • 简化 originator。把 originator 内部状态的版本保留放到了其它类中。

Drawbacks

  • 使用 memento 可能是昂贵的。如果 Originator 拷贝大量的信息存储在 memento,使用 memento 可以导致很大的花费。
  • 保管 mementos 的隐性成本。caretaker 负责删除它保管的 mementos。然而 caretaker 不知道在 memento 中有多少 state。因此,caretaker 可以能导致大量的存储 mementos 的花费。

Observer

What

在对象中定义一对多的依赖,因此当一个对象改变状态时,所有它的依赖者是自动通知和更新的。

Why

Motivation

将系统划分为一组合作的 classes 常见的辅作用是需要维护相关对象之间的一致性。你不想通过使 classes 紧耦合来实现一致性,因为它降低了代码的可重用性。

Applicability

  • 当一个抽象有两个方面,一个依赖另一个。在具体的对象中封装这些方面,让你独立地改变和重用它们。
  • 当你改变一个对象需要改变其他对象,并且你不知道有多少对象需要改变时。
  • 一个对象可以通知其他对象不需要关心这些对象是什么。

Solution

Structure

Participants

  • Subject:1)知道它的 observers。无数个 Observer 对象可能观察一个 subject。2)提供一个接口关联和脱离 Observer 对象。
  • Observer:为接收 subject 改变通知的对象定义一个更新的接口。
  • ConcreteSubject:1)存储 ConcreteObserver 对象的信息。2)当状态改变时发送通知给它的 observers。
  • ConcreteObserver:1)维护一个 ConcreteSubject 的引用。2)存储与 subject 一致的状态。3)实现 Observer 更新接口,保持它的状态与 subject 一致。

Collaborations

  • 当改变发生时,ConcreteSubject 通知它的 observers,让 observers 的状态和自己的保持一致。
  • 当改变通知之后, ConcreteObserver 对象可能查询 subject 的信息。ConcreteObserver 使用这个信息使它的状态与 subject 保持一致。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
public interface Subject{
void attach(Observer observer);
void detach(Observer observer);
void notify();
}
public class ConcreteSubject implements Subject{
private int state;
List<Observer> observers = new ArrayList<>();

public void setState(int state){
this.state = state;
notify();
}
public int getState(){
return this.state;
}
public void attach(Observer observer){
observers.add(observer);
}
public void detach(Observer observer){
observers.remove(observer);
}
public void notify(){
for (Observer observer : observers){
observer.update();
}
}
}
public interface Observer{
void update();
}
public class ConcreteObserver1 implements Observer{
private int state;
private Subject subject;

public ConcreteObserver1(){}
public ConcreteObserver1(Subject subject){
this.subject = subject;
this.state = subject.getState();
}
public int getState(){
return this.state;
}
public void update(){
this.state = subject.getState();
}
}
public class ConcreteObserver2 implements Observer{
private int state;
private Subject subject;

public ConcreteObserver2(){}
public ConcreteObserver2(Subject subject){
this.subject = subject;
this.state = subject.getState();
}
public int getState(){
return this.state;
}
public void update(){
this.state = subject.getState();
}
}
public class Cilent{
public static void main(String[] args){
int state = 1;
Subject subject = new ConcreteSubject(state);
Observer observer1 = new ConcreteObserver1(subject);
Observer observer2 = new ConcreteObserver2(subject);
System.out.println("observer1 state is " + observer1.getState());
System.out.println("observer2 state is " + observer2.getState());
subject.attach(observer1);
subject.attach(observer2);
// automatically notify and update observers
subject.setState(2);
System.out.println("observer1 state update to " + observer1.getState());
System.out.println("observer2 state update to " + observer2.getState());
}
}

Consequences

Benefits

  • 抽象地耦合 Subject 和 Observer。subjecct 不知道它有一组 observers,不知道 observer 具体的类。
  • 支持广播通信。

Drawbacks

  • 意外的更新。可能会导致 observers 很难追踪的虚假更新。

State

What

当一个对象的内部状态改变时允许改变它的行为。这个对象好像更改了它的 classs。

Why

Motivation

一个对象需要在不同的状态表现不同的行为。

例子:TCPConnection class 他表示一个网络连接。一个 TCPConnection object 可可能是多个不同状态中的一个,如:Established,Listening,Closed。当一个 TCPConnection 对象接收到请求时,它可以根据当前的状态进行响应。

Applicability

  • 一个对象的行为取决于它的状态,并且它必须根据它的状态在运行时改变它的行为。
  • 操作有大量的多条件语句,这些语句取决于对象的状态。

Solution

Structure

Participants

  • Context:1)定义 Client 想要的接口。2)维护一个 ConcreteState 子类的实例,它定义了当前状态。
  • State:定义一个接口去封装与 Context 的特殊状态相关的行为。
  • ConcreteState:每个子类实现与 Context 的状态相关的行为。

Collaborations

  • Context 将特定状态的请求委托给当前的 ConcreteState 对象。
  • Context 可以将自身作为参数传递给处理请求的 State 对象。
  • Context 是 Client 的主要接口。Client 可以通过 State 对象配置 context。一旦 Context 配置了,它的 client 不需要直接处理 State 对象。
  • 无论是 Context 还是 ConcreteState 子类都能决定哪个状态接替另一个和在什么情况下。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Context{
private State state;
public Context(){}
public Context(State state){
this.state = state;
}
public void setState(State state){
this.state = state;
}
public void request(){
this.state.handle()
}
}

public interface State{
void handle();
}
public class ConcreteStateA implements State{
public void handle(){
System.out.println("handle by ConcreteStateA");
}
}
public class ConcreteStateB implements State{
public void handle(){
System.out.println("handle by ConcreteStateB");
}
}

public class Client{
public static void main(String[] args){
State state = new ConcreteStateA();
Context context = new Context(state);
context.request();
state = new ConcreteStateB();
context.setState(state);
context.request();
}
}

Consequences

Benefits

  • 它本地化特定状态的行为,它为不同的状态划分行为。
  • 它使状态转换变得明确。
  • 状态对象可以共享。

Strategy

What

定义一组算法,封装每一个,以及让它们是可互换的。Strategy 使算法的改变独立于 Client。

Why

Motivation

一个行为可能切换不同的实现方式。

Applicability

  • 许多相关的 classes 仅在行为上有所不同。Strategy 提供了一种使用多种行为之一配置 class 的方法。
  • 你需要不同的算法。
  • 算法使用了 Client 不应该知道的数据。
  • 一个类定义了许多行为,这些行为在其操作中显示为多个条件语句。代替条件,把相关的条件分支移到它们自己的 Strategy class 中。

Solution

Structure

Participants

  • Strategy:声明所有支持的算法通用的接口。Context 使用这个接口去调用 ConcreteStrategy 定义的算法。
  • ConcreteStrategy:使用 Strategy 实现算法。
  • Context:1)配置了一个 ConcreteStrategy 对象。2)维护一个 Strategy 对象的参考。3)可能定义一个接口让 Strategy 访问它的数据。

Collaborations

  • Strategy 和 Context 交互以实现所选的算法。当算法调用时,Context 可能将算法需要的所有数据传递给 Strategy。或者,Context 把自己作为参数传递给 Strategy 操作。这样,Strategy 可以根据需要回调 Context。
  • Context 将来自它的 Client 的请求转发给它的 Strategy。Client 通常创建和传递 ConcreteStrategy 对象给 Context。之后,Client 仅与 Context 交互。通常会有一些列的 ConcreteStrategy 类供 Client 选择。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public interface Strategy{
public void algorithmInterface();
}
public ConcreteStrategyA implements Strategy{
public void algorithmInterface(){
System.out.println("algorithm implements by ConcreteStrategyA");
}
}
public ConcreteStrategyB implements Strategy{
public void algorithmInterface(){
System.out.println("algorithm implements by ConcreteStrategyB");
}
}

public class Context{
private Strategy strategy;

public contextInterface(Strategy strategy){
this.strategy = strategy;
}
public void runAlgorithm(){
this.strategy.algorithmInterface();
}
}
public class Client{
public static void main(String[] args){
Strategy strategyA = new ConcreteStrategyA();
Strategy strategyB = new ConcreteStrategyB();
Context context = new Context();
context.contextInterface(strategyA);
context.runAlgorithm();
context.contextInterface(strategyB);
context.runAlgorithm();
}
}

Consequences

Benefits

  • 相关的算法家族。Strategy classes 的层级结构定义了一组让 Context 重用的算法或行为。
  • 它是子类化的替代方法。你可以使用 inheritance 的方式去支持多种算法或行为。你可以 subclass Context class 直接执行不同的行为。但这将硬性地把 behavior 关联到 Context。
  • Strategy 可以消除条件语句。
  • 多种实现方式。

Drawbacks

  • Client 必须知道 Strategies 之间的不同。这个模式有个潜在的缺点就是 Client 在选择合适的 strategy 之前必须理解 strategies 有什么不同。
  • 在 Strategy 和 Context 之间有交流消耗。所有 ConreteStrategy 共享 Strategy 接口,无论它们实现的算法是简单还是复杂的。因此,某些 ConcreteStrategy 可能不适用接口传递的所有信息。这就意味着 Context 可能会创建和初始化未使用的参数。
  • 它增加了对象的数量。

Template Method

What

在操作中定义算法的骨架,将某些步骤推迟到子类。Template Method 让子类重新定义算法的某些步骤,而无需更改算法的结构。

Why

Motivation

通过使用抽象操作定义算法的某些步骤,模板方法可以固定其顺序,但可以让子类更改这些步骤以适合其需求。

Applicability

  • 算法不变的部分仅实现一次,并将可变化的行为留给子类来实现。
  • 子类间的共同行为应该分解并集中在一个共同类中,以避免代码重复。
  • 控制子类扩展。你可以定义一个 template method,它叫做在特定点调用 hook 操作,从而允许在哪些点进行扩展。

Solution

Structure

Participants

  • AbstractClass:1)定义抽象的基本操作。2)实现 template method 定义算法骨架。
  • ConcreteClass:实现基本操作以完成子类具体的算法步骤。

Collaborations

  • ConcreteClass 依赖 AbstractClass 实现算法不变的步骤。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class AbstractClass{
public void templateMethod(){
primitiveOperation1();
primitiveOperation2();
}
abstract void primitiveOperation1();
abstract void primitiveOperation2();
}
public class ConcreteClass extends AbstractClass{
public void primitiveOperation1(){
System.out.println("operation1...");
}
public void primitiveOperation2(){
System.out.println("operation2...");
}
}
public class Client{
public static void main(String[] args){
AbstrctClass target = new ConcreteClass();
target.templeateMethod();
}
}

Consequences

Benefits

  • 提高代码的复用性。

Visitor

What

Visitor 表示要在对象结构的元素上执行的操作。Visitor 可以让你定义新的的操作,而无需更改其所操作的元素的类。

Why

Motivation

抽象父类定义了一组操作,不同的子类不一定需要实现所有的操作。强行将父类的所有操作放在一个不需要这个方法的子类中,会让人感到疑惑,以及难以维护。

上面这种情况可以使用 Visitor 将对象结构和对对象的操作分离,并且它可以让你轻易的增加新的操作。

Applicability

  • 一个对象结构包含很多不同接口的类的对象,你想要根据它们具体的类来执行这些对象的操作。
  • 需要对一个对象结构中的对象执行许多不同且不相关的操作,并且你要避免使用这些操作“污染”它们的类。Vistor 让你将相关的操作放在一起,通过把它们定义在一个类中。
  • 定义对象结构的类很少改变,但是你经常想要在该结构上定义新的操作。更改对象结构类需要重新定义所有 Visitor 的接口,这可能导致很高的花费。如果你的对象结构类经常改变,那么它可能更适合把操作定义在类中。

Solution

Structure

Participants

  • Visitor:为对象结构中每一个 ConcreteElement 类声明一个 Visit 操作。
  • ConcreteVisitor:实现 Visitor 中声明的每个操作。
  • Element:定义一个 Accept 操作,它接收一个 visitor 作为参数。
  • ConcreteElement:实现 Accept 操作。
  • ObjectStructure:1)枚举它的元素。2)提供一个高层级的接口去允许 Visitor 访问它的元素。3)它可以是组合(Composite)或者集合(List or Set)。

Collaborations

  • Client 创建一个 ConcreteVisitor 对象,然后遍历对象结构,和 visitor 一起访问每个元素。
  • 当一个元素被访问,它调用对应的 Visitor 操作。如果需要,这个元素支持把自己作为参数传给这个操作,让 visitor 访问它的状态。

Implementations

Click to expand!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public interface Visitor{
int visit(Element concreteElementA);
int visit(Element concreteElementB);
}
public class ComputeSumConcreteVisitor1 implements Visitor{
private int result = 0;

public void visit(Element concreteElementA){
result += concreteElementA.getValue();
}
public void visit(Element concreteElementB){
result += concreteElementB.getValue();
}
public int getSum(){
return this.result;
}
}
public class ComputeProductConcreteVisitor2 implements Visitor{
private int result = 1;

public void visit(Element concreteElementA){
result *= concreteElementA.getValue();
}
public void visit(Element concreteElementB){
result *= concreteElementB.getValue();
}
public int getProduct(){
return this.totalValue;
}
}

public interface Element{
int accept(Visitor visitor);
}
public class ConcreteElementA implements Element{
int value;
public ConcreteElementA(){}
public ConcreteElementA(int value){
this.value = value;
}
int accept(Visitor visitor){
return visitor.visit(this);
}
}
public class ConcreteElementB implements Element{
int value;
public ConcreteElementB(){}
public ConcreteElementB(int value){
this.value = value;
}
int accept(Visitor visitor){
return visitor.visit(this);
}
}

public class Client{
pubilc static void main(String[] args){
Element[] elements = new Element[]{new ConcreteElementA(1), new ConcreteElementB(2)};

// operation 1 in elements object strucutre
Visitor sumVisitor = new ComputeSumConcreteVisitor1();
for (Element e : elements){
e.accept(sumVisitor);
}
int sum = sumVisitor.getSum();

// operation 2 in elements object strucutre
Visitor productVisitor = new ComputeProductConcreteVisitor2();
for (Element e : elements){
e.accept(productVisitor);
}
int product = productVisitor.getProduct();
}
}

Consequences

Benefits

  • Visitor 使得添加新的操作很容易。通过添加一个新的 visitor 来定义对 object 结构的新的操作。
  • Visitor 收集相关的操作并将不相关的操作分开。
  • 跨 class 层级结构进行访问。你可以定义没有公共父类的 visit objects。你可以在 Visitor 接口中添加任何类型的对象。
  • 积累状态。

Drawbacks

  • 增加新的 ConcreteElement class 是复杂的。每个ConcreteVisitor 都需要添加操作这个元素的新的方法。
  • 打破封装。该模式中的 element 必须提供访问元素内部状态的 public 方法。

References

[1] Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides

Contents
  1. 1. Behavioral Patterns
  2. 2. Chain of Responsibility
    1. 2.1. What
    2. 2.2. Why
    3. 2.3. Solution
    4. 2.4. Consequences
  3. 3. Command
    1. 3.1. What
    2. 3.2. Why
    3. 3.3. Solution
    4. 3.4. Consequences
  4. 4. Interpreter
    1. 4.1. What
    2. 4.2. Why
    3. 4.3. Solution
    4. 4.4. Consequences
  5. 5. Iterator
    1. 5.1. What
    2. 5.2. Why
    3. 5.3. Solution
    4. 5.4. Consequences
  6. 6. Mediator
    1. 6.1. What
    2. 6.2. Why
    3. 6.3. Solution
    4. 6.4. Consequences
  7. 7. Memento
    1. 7.1. What
    2. 7.2. Why
    3. 7.3. Solution
    4. 7.4. Consequences
  8. 8. Observer
    1. 8.1. What
    2. 8.2. Why
    3. 8.3. Solution
    4. 8.4. Consequences
  9. 9. State
    1. 9.1. What
    2. 9.2. Why
    3. 9.3. Solution
    4. 9.4. Consequences
  10. 10. Strategy
    1. 10.1. What
    2. 10.2. Why
    3. 10.3. Solution
    4. 10.4. Consequences
  11. 11. Template Method
    1. 11.1. What
    2. 11.2. Why
    3. 11.3. Solution
    4. 11.4. Consequences
  12. 12. Visitor
    1. 12.1. What
    2. 12.2. Why
    3. 12.3. Solution
    4. 12.4. Consequences
  13. 13. References