备忘录模式

  备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于 行为型模式

如果想了解备忘录模式的具体的介绍，菜鸟教程介绍得比较详细↓
菜鸟教程-备忘录模式

结构图

优缺点

优点：

1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。
2、实现了信息的封装，使得用户不需要关心状态的保存细节。

缺点：

消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

使用场景

1、需要保存/恢复数据的相关状态场景。
2、提供一个可回滚的操作。

实现代码

这个模式比较好理解,就比如说我们在玩游戏的时候,你存了档,然后进行回档的话,其实就是备忘录模式
Windows中我们常用的Ctrl+z也就是这个模式。

Memento模式中Originator是发起人，负责创建一个备忘录Memento，用以记录当前时刻它的内部状态，并可使用备忘录恢复内部状态;Memento是备忘录，负责存储Originator对象的内部状态，并可防止Originator以外的其他对象访问备忘录Memento；Caretaker是管理者，负责保存好备忘录的Memento，不能对备忘录的内容进行操作或检查。

模拟一个小游戏,我们让一个兔子进行随机的运动,每当一个时刻,我们就记录它的位置,
代码如下:

public class Main {

    public static void main(String[] args) {
        Originator originator = new Originator();
        CareTaker careTaker = new CareTaker();
        Rabbit rabbit = new Rabbit(10, 20);
        for (int i = 0; i < 10; i++) {
            switch ((int) (Math.random() * 10) % 4) {
                case 0:
                    rabbit.x += 5;
                    break;
                case 1:
                    rabbit.x -= 5;
                    break;
                case 2:
                    rabbit.y += 5;
                    break;
                case 3:
                    rabbit.y -= 5;
                    break;
                default:
                    System.out.println("no");
                    break;
            }

            if (i % 3 == 0) {
                originator.setState(rabbit.toString());
                careTaker.add(originator.saveStateToMemento());
            }
        }
        for (int j = 0; j < 3; j++) {
            originator.getStateFromMemento(careTaker.get(j));
            System.out.println(j + " --> " + originator.getState());
        }
    }

}

public class Rabbit {
    int x;
    int y;

    public Rabbit(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Rabbit{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

public class Memento {
    private String state;

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

    public String getState() {
        return state;
    }
}

public class Originator {
    private String state;

    public String getState() {
        return state;
    }

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

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

    public void getStateFromMemento(Memento Memento){
        state = Memento.getState();
    }
}

public class CareTaker {
   private List<Memento> mementoList = new ArrayList<Memento>();
 
   public void add(Memento state){
      mementoList.add(state);
   }
 
   public Memento get(int index){
      return mementoList.get(index);
   }

   public int getSize(){
      return mementoList.size();
   }
}

输出结果:

0 --> Rabbit{x=5, y=20}
1 --> Rabbit{x=5, y=25}
2 --> Rabbit{x=10, y=25}

输出结果就是记录着Rabbit的移动轨迹。

当我们在存档的时候,需要将当前的数据保存起来,保存的数据就存在Originator中
如果我们想要读档的时候,那么将Originator中的数据读出即可,并且,读档的功能也是通过Originator实现的
但是我们存档当然不可能就是存一个,多个存档就需要存储在CareTaker中

这就是备忘录的基本思想,这个模式在开发的时候还是用得比较多的模式,需要好好理解一下