备忘录模式

在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。
|- 简而言之，复制一份对象的内部状态，保存下来以备不时之需。

白箱备忘录模式

备忘录角色对任何对象都提供一个接口（宽接口），备忘录角色的内部所存储的状态就对所有对象公开。
例：

运行结果如下：
当前状态：on
当前状态：off
on

黑箱备忘录模式

备忘录角色对发起人（Originator）角色对象提供一个宽接口，而为其他对象提供一个窄接口。
|- 在JAVA语言中，实现双重接口的办法就是将备忘录角色类设计成发起人角色类的内部成员类。
例：

运行结果如下：
当前状态 -->on
当前状态 -->off
当前状态 -->on

多重检查点

往往系统中部只需要恢复对象的某一个状态，而是要恢复多个状态。
例：

public class Originator {
    private List<String> states;
    //检查点指数
    private int index;
    /**
     * 构造函数
     */
    public Originator(){
        states = new ArrayList<String>();
        index = 0;
    }
    /**
     * 工厂方法，返还一个新的备忘录对象
     */
    public Memento createMemento(){
        return new Memento(states , index);
    }
    /**
     * 将发起人恢复到备忘录对象记录的状态上
     */
    public void restoreMemento(Memento memento){
        states = memento.getStates();
        index = memento.getIndex();
    }
    /**
     * 状态的赋值方法
     */
    public void setState(String state){
        states.add(state);
        index++;
    }
    /**
     * 辅助方法，打印所有状态
     */
    public void printStates(){

        for(String state : states){
            System.out.println(state);
        }
    }
}
public class Memento {
    private List<String> states;
    private int index;
    /**
     * 构造函数
     */
    public Memento(List<String> states , int index){
        this.states = new ArrayList<String>(states);
        this.index = index;
    }
    public List<String> getStates() {
        return states;
    }
    public int getIndex() {
        return index;
    }
}
public class CareTaker {
    private Originator o;
    private List<Memento> mementos = new ArrayList<Memento>();
    private int current;
    /**
     * 构造函数
     */
    public CareTaker(Originator o){
        this.o = o;
        current = 0;
    }
    /**
     * 创建一个新的检查点
     */
    public int createMemento(){
        Memento memento = o.createMemento();
        mementos.add(memento);
        return current++;
    }
    /**
     * 将发起人恢复到某个检查点
     */
    public void restoreMemento(int index){
        Memento memento = mementos.get(index);
        o.restoreMemento(memento);
    }
    /**
     * 将某个检查点删除
     */
    public void removeMemento(int index){
        mementos.remove(index);
    }
}
public class Client {
    public static void main(String[] args) {

        Originator o = new Originator();
        CareTaker c = new CareTaker(o);
        //改变状态
        o.setState("state 0");
        //建立一个检查点
        c.createMemento();
        //改变状态
        o.setState("state 1");
        //建立一个检查点
        c.createMemento();
        //改变状态
        o.setState("state 2");
        //建立一个检查点
        c.createMemento();
        //改变状态
        o.setState("state 3");
        //建立一个检查点
        c.createMemento();
        //打印出所有检查点
        o.printStates();
        System.out.println("-----------------恢复检查点-----------------");
        //恢复到第二个检查点
        c.restoreMemento(2);
        //打印出所有检查点
        o.printStates();
    }

}

运行结果如下：
state 0
state 1
state 2
state 3
-----------------恢复检查点-----------------
state 0
state 1
state 2

状态模式

允许一个对象在其内部状态改变的时候改变其行为，这个对象看上去就像是改变了它的类一样。
|- 把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。
例（思路模型）：

运行结果如下：
ConcreteStateA handle :test
ConcreteStateB handle :test

例（具体事例：投票事件，分为普通投票、重复投票、恶意刷票、黑名单禁止刷票几种状态）：

运行结果如下：
恭喜投票成功
请不要重复投票
请不要重复投票
请不要重复投票
你有恶意刷屏行为，取消投票资格
你有恶意刷屏行为，取消投票资格
你有恶意刷屏行为，取消投票资格
你有恶意刷屏行为，取消投票资格
进入黑名单，将禁止登录和使用本系统

本文转载自微信公众号【java学习之道】。

原文链接：https://mp.weixin.qq.com/s?__biz=MzU4NzYwNDAwMg==&mid=2247484052&idx=1&sn=d86e563bfdc37bc0c0dd85e9a1dc64a9&chksm=fde8cbd9ca9f42cf4f9891d576991b124b3f2fdaf41fddb8bc8438f14da9cd3d0d7950ff2c9f&scene=0#rd