走进设计模式(四)-行为型模式(下)

• 命令模式
• 备忘录模式
• 状态模式
• 访问者模式
• 中介者模式
• 解释器模式

0. 命令模式

将一个请求封装成一个对象，从而让用户使用不同的请求把客户端参数化，对请求排队或者记录请求日志，以及支持可撤销的奥做。

Receiver 接受者角色
Command 命令类抽象接口
ConcreateCommand 具体命令角色
Invoker 请求者角色
Client 客户端

public class Receiver {
    public void action(){
        System.err.println("具体的操作");
    }
}

public interface Command {
    void execute();
}

public class ConcreateCommand implements Command {
    private Receiver mReceiver;

    public ConcreateCommand(Receiver receiver){
        this.mReceiver = receiver;
    }

    @Override
    public void execute() {
        mReceiver.action();
    }
}

public class Invoker {

    private Command command;
    public Invoker(Command command){
        this.command = command;
    }

    public void action(){
        command.execute();
    }

}

    public static void main(String[] args){
        Receiver receiver = new Receiver();
        ConcreateCommand concreateCommand = new ConcreateCommand(receiver);
        Invoker invoker = new Invoker(concreateCommand);
        invoker.action();
    }

2. 备忘录模式

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

简单点来说就是在退出的时候保存状态，下一次从保存的状态中取出。
Originator 负责创建一个备忘录
Memento 备忘录角色
Caretaker 负责存储备忘录

public class Caretaker {
    private Memento memento;
    /**
     * 备忘录的取值方法
     */
    public Memento retrieveMemento(){
        return this.memento;
    }
    /**
     * 备忘录的赋值方法
     */
    public void saveMemento(Memento memento){
        this.memento = memento;
    }
}



public class Memento {

    private String state;
    public Memento(String state){
        this.state = state;
    }
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

}

public class Originator {
    private String state;

    public Memento createMemento(){
        return new Memento(state);
    }

    public void restoreMemento(Memento memento){
        this.state = memento.getState();
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
        System.out.println("当前状态：" + this.state);
    }

}

    public static void main(String[] args){
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        caretaker.saveMemento(new Memento("start"));

        originator.setState("end");
        originator.restoreMemento(caretaker.retrieveMemento());
    }

3. 状态模式

一个对象的内在状态改变时允许改变行为，这个对象看起来像是改变它的行为。

对象的行为是跟着状态走的。

Context 环境类，定义客户感兴趣的接口
State 抽象状态类或者状态接口，定义一个或一组接口，表示该状态的行为
ConcreateStateA、B 具体的状态类

public interface TvState {

    public void nextChannel();
    public void prevChannel();

}

public class ConcreateStateOff implements TvState {
    @Override
    public void nextChannel() {
        System.err.println("没开机");
    }

    @Override
    public void prevChannel() {
        System.err.println("没开机");
    }
}


public class Context {

    private TvState state;

    public void setState(TvState state){
        this.state = state;
    }

    public void nextChannel(){
        state.nextChannel();
    }

    public void prevChannel(){
        state.prevChannel();
    }

}

    public static void main(String[] args){
        Context context = new Context();
        context.setState(new ConcreateStateOn());
        context.nextChannel();
        context.prevChannel();

        context.setState(new ConcreateStateOff());
        context.nextChannel();
        context.prevChannel();
    }

4. 访问者模式

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作

• Visitor 接口或者抽象类，它定义了对每一个元素访问的行为，他的参数就是可以访问的元素
• ConcreateVisitor 具体的访问者
• Element 元素接口或者抽象类
• ElementA、B
• ObjectStructure 定义当中所提到的对象结构

这个模式没理解到位。

5. 中介者模式

包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。

中介者模式起个和事老的作用。

• Mediator 抽象中介者角色
• ConcreateMediator 具体中介者角色