设计模式——行为型模式

一：目录
1. 策略模式（Strategy）
2.状态模式（State）
3.责任链模式（Chain Of Responsibility）
4.解释器模式（Interpreter）
5.命令模式（Command）
6.观察者模式（Observer）
7.备忘录模式（Memento）
8.迭代器模式（Iterator）
9.模板方法模式（Template Method）
10.访问者模式（Visitor）
11.中介者模式（Mediator）

二：详细介绍

2.1 策略模式（Strategy）

2.1.1 简介：

策略模式的主要目的是将算法的定义与使用分开，也就是将算法的行为与环境分开，将算法的定义放在专门的策略类汇总，每一个策略类封装了一种实现算法，使用算法的环境类针对抽象策略类进行编程，符合“依赖倒转原则”。

2.2 状态模式（State）

• 封装了状态的转换原则，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中
• 将所有与某个状态有关的行为放到一个类中，只需要注入一个不同的状态对象即可使环境对象拥有不同的行为
• 允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块

缺点：

• 状态模式必然会增加系统中类和对象的数量，导致运行开销增大；
• 状态模式的结构与实现都比较复杂，使用不当容易导致程序结构与代码的混乱，增加设计的难度；
• 状态模式对“开闭原则”支持不太好，增加新的状态需要修改负责状态维护的代码；

2.2.3 类图：

2.3 责任链模式（Chain Of Responsibility）
2.3.1 描述：
责任链模式是一种对象的行为模式。在责任链模式中，对象持有下家的引用而连接成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上哪个对象最终处理这个请求，使得系统可以在不影响客户端的情况下动态的重新组织和分配责任。
纯与不纯的责任链：
纯责任链：要么处理请求，要么交给下家处理；不允许具体处理对象承担了一部分责任之后，又向下传递；一个请求必须被某一个处理对象所接收
不纯的责任链：纯的责任链很少见，能看到的基本上都是不纯的。

例如：击鼓传花，花束在每个人之间传递，当鼓声停下来，花在谁手中，谁就要喝酒行令。

2.3.3 类图：

2.4 解释器模式（Interpreter）

2.2.3 描述：

2.2.3 类图：

2.5 命令模式（Command）

• 命令模式使新的命令很容易被加到系统里
• 允许接收请求的乙方决定是否要否决请求
• 较容易的设计一个命令队列
• 可以容易的实现对请求的撤销和恢复
• 在需要的情况下，可以较容易地将命令记入日志

命令模式涉及到5个角色，分别为：

• 客户端（Client）角色：创建一个具体命令（ConcreteCommand）对象并确定其接受者
• 命令（Command）角色：声明了一个所有具体命令类的抽象接口
• 具体命令（ConcreteCommand）角色：定义一个接收者与行为之间的弱耦合；实现execute()方法，负责调用接收者的相应操作。execute()方法通常叫做执行方法
• 请求者（Invoker）角色：负责调用命令对象执行请求，相关的方法叫做行动方法
• 接收者（Receiver）角色：负责具体实施和执行一个请求。任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法

2.5.4 类图：

2.5.4 代码：

interface Command { 
    void execute(); } class ConcreteCommand implements Command { 
    private Receiver receiver; public ConcreteCommand(Receiver receiver) { 
    this.receiver = receiver; } @Override public void execute() { 
    System.out.println(this.getClass().getName() + " execute."); receiver.action(); } } class Invoker { 
    private Command command; public Invoker(Command command) { 
    this.command = command; } public void action() { 
    System.out.println(getClass().getName() + " action."); command.execute(); } } class Receiver { 
    public void action() { 
    System.out.println(getClass().getName() + " action."); } } public class CommandClient { 
    public static void main(String[] args) { 
    Receiver receiver = new Receiver(); Command command = new ConcreteCommand(receiver); Invoker invoker = new Invoker(command); invoker.action(); } } 

2.6 观察者模式（Observer）

2.6.2 类图：

2.6.3 代码：

interface Observer { 
    void update(); } class ConcreteObserver implements Observer { 
    public ConcreteObserver(Subject subject) { 
    subject.addObserver(this); } @Override public void update() { 
    System.out.println(getClass().getName() + " 得到通知."); } } abstract class Subject { 
    Vector<Observer> observers = new Vector<>(); void addObserver(Observer observer) { 
    observers.addElement(observer); } void removeObserver(Observer observer) { 
    observers.remove(observer); } public abstract void change(); } class ConcreteSubject extends Subject { 
    private String state; @Override public void change() { 
    System.out.println(getClass().getName() + " state changed."); this.notifyObservers(); } private void notifyObservers() { 
    if(!CollectionUtils.isEmpty(observers)) { 
    for(Observer observer : observers) { 
    observer.update(); } } } } public class ObserverClient { 
    public static void main(String[] args) { 
    Subject subject = new ConcreteSubject(); Observer observer = new ConcreteObserver(subject); subject.change(); } } 

2.7 备忘录模式（Memento）

2.7.2 类图：

2.8 迭代器模式（Iterator）

2.9 模板方法模式（Template Method）

2.10 访问者模式（Visitor）

2.11 中介者模式（Mediator）