备忘录模式

概念：顾名思义就是用来备份存档的
书面意思是指：是行为型模式设计模式之一，该模式用于保存对象当前状态，并且在之后可以再次恢复到此状态。备忘录模式实现的方式需要保证被保存的对象状态不能被对象从外部访问，目的是为了保护被保存的这些对象状态的完整性以及内部实现不向外暴露。
结构：
发起人（Originator） 用来创建备忘录和恢复备忘录（把备忘录中的属性值保存到发起人对象中，通过发起人操作备忘录对象。）
备忘录（Memento） 用于存储 Originator 的内部状态，并且只能被 Originator 对象访问 。
负责人（Caretaker）用来存储备忘录和获取备忘录
备忘录又分白箱模式和黑箱模式
白箱模式：对内、外都提供宽接口
黑箱模式：对内提供窄接口，对外提供宽接口
宽接口：这里指的是备忘录角色可以被除了发起人角色访问外还可以被其它对象访问
窄接口：指的是只能被发起人角色访问，也就是定义为发起人角色的内部类（然后对外提供一个空接口）
如下 ：

白箱模式：
//备忘录角色
 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;
    }
}

//负责人角色（备忘录管理员角色）
 class Caretaker {
    private Memento memento;
    /**
     * 备忘录的取值方法
     */
    public Memento retrieveMemento(){
        return this.memento;
    }
    /**
     * 备忘录的赋值方法
     */
    public void saveMemento(Memento memento){
        this.memento = memento;
    }

}
/**
 * 对备忘录进行管理、保存和提供备忘录。
 * @Classname Originator
 * @Description 备忘录模式
 * @Date 2021/3/21 20:52
 * @Created by 86386
 */
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);
    }
}
class Client {
    public static void main(String[] args) {

        //发起人创建对象
        Originator o = new Originator();
        //负责人
        Caretaker c = new Caretaker();
        //改变负责人对象的状态
        o.setState("On");
        //创建备忘录对象，并将发起人对象的状态储存起来
        c.saveMemento(o.createMemento());
        //修改发起人的状态
        o.setState("Off");
        //恢复发起人对象的状态
        o.restoreMemento(c.retrieveMemento());
        System.out.println(o.getState());
    }
}
黑箱模式：
package memorial;

/**
 * @Classname BlackOriginator
 * @Description TODO
 * @Date 2021/3/23 22:56
 * @Created by 86386
 */
public class BlackOriginator {
    private String state;

    public String getState() {
        return state;
    }
    public void setState(String state) {
        this.state = state;
        System.out.println("赋值状态：" + state);
    }
    /**
     * 工厂方法，返还一个新的备忘录对象
     */
    public MementoIF createMemento(){
        return new Memento(state);
    }
    /**
     * 发起人恢复到备忘录对象记录的状态
     */
    public void restoreMemento(MementoIF memento){
        this.setState(((Memento)memento).getState());
    }

    private class Memento implements MementoIF{

        private String state;
        /**
         * 构造方法
         */
        private Memento(String state){
            this.state = state;
        }

        private String getState() {
            return state;
        }
        private void setState(String state) {
            this.state = state;
        }
    }

}
 interface MementoIF {

}
 class Caretaker1 {

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

    public static void main(String[] args) {
        BlackOriginator o = new BlackOriginator();
        Caretaker1 c = new Caretaker1();
        //改变负责人对象的状态
        o.setState("On");
        //创建备忘录对象，并将发起人对象的状态存储起来
        c.saveMemento(o.createMemento());
        //修改发起人对象的状态
        o.setState("Off");
        //恢复发起人对象的状态
        o.restoreMemento(c.retrieveMemento());
    }

}
多重检查点
package memorial;

import java.util.ArrayList;
import java.util.List;

/**
 * @Classname Originator1
 * @Description 多重检查点
 * 　　前面所给出的白箱和黑箱的示意性实现都是只存储一个状态的简单实现，也可以叫做只有一个检查点。
 * 常见的系统往往需要存储不止一个状态，而是需要存储多个状态，或者叫做有多个检查点。
 * 　　备忘录模式可以将发起人对象的状态存储到备忘录对象里面，备忘录模式可以将发起人对象恢复到备忘录对象所存储的某一个检查点上。
 * 下面给出一个示意性的、有多重检查点的备忘录模式的实现。
 * @Date 2021/3/23 23:31
 * @Created by 86386
 */
public class Originator1 {

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

        for(String state : states){
            System.out.println(state);
        }
    }
}
class Memento1 {

    private List<String> states;
    private int index;

    /**
     * 构造函数
     */
    public Memento1(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;
    }
}
    class Caretaker2 {

        private Originator1 o;
        private List<Memento1> mementos = new ArrayList<Memento1>();
        private int current;
        /**
         * 构造函数
         */
        public Caretaker2(Originator1 o){
            this.o = o;
            current = 0;
        }
        /**
         * 创建一个新的检查点
         */
        public int createMemento(){
            Memento1 memento1 = o.createMemento();
            mementos.add(memento1);
            return current++;
        }
        /**
         * 将发起人恢复到某个检查点
         */
        public void restoreMemento(int index){
            Memento1 memento1 = mementos.get(index);
            o.restoreMemento(memento1);
        }
        /**
         * 将某个检查点删除
         */
        public void removeMemento(int index){
            mementos.remove(index);
        }
    }
     class Client2 {

        public static void main(String[] args) {

            Originator1 o = new Originator1();
            Caretaker2 c = new Caretaker2(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();
        }

    }