备忘录模式

备忘录模式

案例引入

游戏角色状态恢复问题

游戏角色有攻击力，防御力等，在大战BOSS前保存自身的状态(攻击力，防御力)，当大战BOSS后攻击力和防御力下降，从备忘录对象恢复到大站前的状态。
传统方式实现案例

创建一个游戏角色类对应的状态类，给每个游戏角色对象，对应一个对应状态类的对象，用来保存状态。
传统方式实现问题分析

• 1.一个游戏对象，就对应一个保存游戏状态的对象，这样如果游戏中有很多游戏角色，也会产生很多与之对应的状态角色，不利于管理，其内存开销很大。
  
• 2.传统的方式，就是简单的备份，new一个另外的对象来，再把需要备份的数据放到这个新对象，但这就暴露了对象内部的细节。
  
• 3.解决方案 => 备忘录模式。
  

基本介绍

• 1.备忘录模式(Memento Pattern)在不破坏封装性的前提下，捕获了一个对象的内部状态，并在该对象之外保存了该状态。这样需要恢复到原有状态时，就可将该对象恢复到原先保存时的状态。
  
• 2.也可以这样理解备忘录模式，现实生活中的备忘录是用来记录某些要去做的事情，或者是记录已经达成的共同意见的事情，以防忘记了。在软件层面，备忘录也有着相同的含义，备忘录对象主要用来记录一个对象的某种状态，或者数据，当要做回退时，可用从备忘录对象里获取原有的状态数据进行恢复。
  
• 3.备忘录模式属于行为型模式。
  

备忘录模式原理类图


角色分析

• 1.Originator是原始类，代表需要保存状态和数据信息的类。
  
• 2.Memento是备忘录类，是保存Originator类对象状态和数据信息的类。
  
• 3.Caretaker是一个管理备忘录的类，其中有一个保存备忘录对象的集合属性。
  
• 4.说明，如果希望保存多个Originator对象的不同时间的状态，只需要用HashMap保存就可以了
  

原理的代码

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 保存对象的状态/数据
5. */
6. public class Memento {
7.     //保存的状态
8.     private String savedState;
10.     public Memento(String s){
11.         savedState = s;
12.     }
14.     public String getStateInfo(){//获取状态信息
15.         return savedState;
16.     }
17. }
18. /**
19. * @author 长名06
20. * @version 1.0
21. * 游戏角色类 需要保存状态的类
22. */
23. public class Originator {
25.     //状态信息
26.     private String state;
28.     public String getState() {
29.         return state;
30.     }
32.     public void setState(String state) {
33.         this.state = state;
34.     }
36.     //可以保存状态信息到备忘录对象中，并返回该备忘录对象
37.     public Memento saveStateMemento(){
38.         return new Memento(state);
39.     }
41.     //通过备忘录对象，恢复对象状态
42.     public void restoreStateFromMemento(Memento memento){
43.         state = memento.getStateInfo();
44.     }
45. }
46. /**
47. * @author 长名06
48. * @version 1.0
49. * 管理所有的备忘录对象
50. */
51. public class Caretaker {
52.     private List<Memento> mementoList = new ArrayList<>();
54.     public void add(Memento memento){
55.         mementoList.add(memento);
56.     }
58.     /**
59.      * 根据索引获取 原始对象 对应的 备忘录对象
60.      * @param index
61.      * @return
62.      */
63.     public Memento get(int index){
64.         return mementoList.get(index);
65.     }
67.     public void delete(Memento memento){
68.         mementoList.remove(memento);
69.     }
70. }
71. public class Client {
72.     public static void main(String[] args) {
73.         Originator originator = new Originator();
74.         Caretaker caretaker = new Caretaker();
75.         originator.setState(" 状态#1 攻击力是100 ");
76.         //保存了状态1
77.         caretaker.add(originator.saveStateMemento());
78.         //保存了状态2
79.         originator.setState(" 状态#2 攻击力是80 ");
80.         caretaker.add(originator.saveStateMemento());
81.         //保存了状态3
82.         originator.setState(" 状态#2 攻击力是60 ");
83.         caretaker.add(originator.saveStateMemento());
85.         System.out.println("当前状态" + originator.getState());
86.         //恢复到状态1
87.         originator.restoreStateFromMemento(caretaker.get(0));
88.         System.out.println("恢复后的装态" + originator.getState());
89.     }
90. }

复制代码

备忘录模式实现案例

案例要求

游戏角色有攻击力和防御力，在打BOSS前保存自身的状态(攻击力和防御力)，当大战BOSS后攻击力和防御力下降，从备忘录对象恢复到大战前的状态。
类图


代码

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 游戏角色的备忘录类
5. */
6. public class Mementor {
8.     private int attackPower;//攻击力
10.     private int defensePower;//防御力
12.     public Mementor(int attackPower,int defensePower){
13.         this.attackPower = attackPower;
14.         this.defensePower = defensePower;
15.     }
17.     public int getAttackPower() {
18.         return attackPower;
19.     }
21.     public void setAttackPower(int attackPower) {
22.         this.attackPower = attackPower;
23.     }
25.     public int getDefensePower() {
26.         return defensePower;
27.     }
29.     public void setDefensePower(int defensePower) {
30.         this.defensePower = defensePower;
31.     }
32. }
33. /**
34. * @author 长名06
35. * @version 1.0
36. * 游戏角色
37. */
38. public class GameRole {
40.     private int attackPower;
42.     private int defensePower;
45.     public Mementor createMementor(){
46.         return new Mementor(attackPower,defensePower);
47.     }
49.     public void restoreStateFromMementor(Mementor mementor){
50.         attackPower = mementor.getAttackPower();
51.         defensePower = mementor.getDefensePower();
52.     }
54.     public void showState(){
55.         System.out.println("游戏角色当前攻击力" + this.attackPower + "防御力" + this.defensePower);
56.     }
58.     public int getAttackPower() {
59.         return attackPower;
60.     }
62.     public void setAttackPower(int attackPower) {
63.         this.attackPower = attackPower;
64.     }
66.     public int getDefensePower() {
67.         return defensePower;
68.     }
70.     public void setDefensePower(int defensePower) {
71.         this.defensePower = defensePower;
72.     }
73. }
74. /**
75. * @author 长名06
76. * @version 1.0
77. * 守护者对象，用于管理(保存游戏状态/数据对象)的对象
78. */
79. public class Caretaker {
81.     //只保存一个角色的一次状态
82.     private Mementor mementor;
84.     //对于一个游戏角色的多个状态
85. //    private List<Mementor> mementorList = new ArrayList<>();
87.     //保存多个游戏角色的状态
88. //    private HashMap<String,ArrayList<Mementor>> rolesMap;
91.     public Mementor getMementor() {
92.         return mementor;
93.     }
95.     public void setMementor(Mementor mementor) {
96.         this.mementor = mementor;
97.     }
98. }
99. public class Client {
100.     public static void main(String[] args) {
101.         GameRole gameRole = new GameRole();
102.         gameRole.setAttackPower(100);
103.         gameRole.setDefensePower(200);
104.         System.out.print("打BOSS前状态\t");
105.         gameRole.showState();
107.         //将当前状态保存到一个备忘录类中
108.         Caretaker caretaker = new Caretaker();
109.         caretaker.setMementor(gameRole.createMementor());
111.         //打BOSS状态下降
112.         gameRole.setDefensePower(100);
113.         gameRole.setAttackPower(50);
114.         //打BOSS后状态
115.         System.out.print("打BOSS后状态\t");
116.         gameRole.showState();
118.         //恢复状态
119.         gameRole.restoreStateFromMementor(caretaker.getMementor());
120.         //展示恢复后的状态
121.         System.out.print("恢复后的状态\t");
122.         gameRole.showState();
123.     }
124. }

复制代码

注意事项和细节

• 1.给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便的回到某个历史的状态。
  
• 2.实现了信息的封装，使得用户不需要关心状态的保存细节。
  
• 3.如果类的成员变量过多，势必会占用比较多的内存资源，而且每次保存都会消耗内存。
  
• 4.适用的应用场景：4.1 后悔药；4.2 打游戏时的存档；4.3 Windows里的ctrl + z； 4.4 浏览器里的后退； 4.5 数据库的事务撤销。
  
• 5.为了节约内存，备忘录模式可以和原型模式配合使用。
  只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！