撤销功能的实现——备忘录模式（四）

21.4 实现多次撤销

Sunny软件公司开发人员通过使用备忘录模式实现了中国象棋棋子的撤销操作，但是使用上述代码只能实现一次撤销，因为在负责人类中只定义一个备忘录对象来保存状态，后面保存的状态会将前一次保存的状态覆盖，但有时候用户需要撤销多步操作。如何实现多次撤销呢？本节将提供一种多次撤销的解决方案，那就是在负责人类中定义一个集合来存储多个备忘录，每个备忘录负责保存一个历史状态，在撤销时可以对备忘录集合进行逆向遍历，回到一个指定的历史状态，而且还可以对备忘录集合进行正向遍历，实现重做(Redo)操作，即取消撤销，让对象状态得到恢复。

改进之后的中国象棋棋子撤销功能结构图如图21-5所示：

撤销功能的实现——备忘录模式（四） - 图1

在图21-5中，我们对负责人类MementoCaretaker进行了修改，在其中定义了一个ArrayList类型的集合对象来存储多个备忘录，其代码如下所示：

  1. import java.util.*;  
  3. class MementoCaretaker {  
  4.     //定义一个集合来存储多个备忘录  
  5.     private ArrayList mementolist = new ArrayList();  
  7.     public ChessmanMemento getMemento(int i) {  
  8.         return (ChessmanMemento)mementolist.get(i);  
  9.     }  
  11.     public void setMemento(ChessmanMemento memento) {  
  12.         mementolist.add(memento);  
  13.     }  
  14. }

编写如下客户端测试代码：

  1. class Client {  
  2. private static int index = -1; //定义一个索引来记录当前状态所在位置  
  3.     private static MementoCaretaker mc = new MementoCaretaker();  
  5.     public static void main(String args[]) {  
  6.         Chessman chess = new Chessman("车",1,1);  
  7.         play(chess);          
  8.         chess.setY(4);  
  9.         play(chess);  
  10.         chess.setX(5);  
  11.         play(chess);      
  12.         undo(chess,index);  
  13.         undo(chess,index);    
  14.         redo(chess,index);  
  15.         redo(chess,index);  
  16.     }  
  18.     //下棋  
  19.     public static void play(Chessman chess) {  
  20.         mc.setMemento(chess.save()); //保存备忘录  
  21.         index ++;   
  22.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
  23.     }  
  25.     //悔棋  
  26.     public static void undo(Chessman chess,int i) {  
  27.         System.out.println("******悔棋******");  
  28.         index --;   
  29.         chess.restore(mc.getMemento(i-1)); //撤销到上一个备忘录  
  30.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
  31.     }  
  33.     //撤销悔棋  
  34.     public static void redo(Chessman chess,int i) {  
  35.         System.out.println("******撤销悔棋******");   
  36.         index ++;   
  37.         chess.restore(mc.getMemento(i+1)); //恢复到下一个备忘录  
  38.         System.out.println("棋子" + chess.getLabel() + "当前位置为：" + "第" + chess.getX() + "行" + "第" + chess.getY() + "列。");  
  39.     }  
  40. }

编译并运行程序，输出结果如下：

  1. 棋子车当前位置为：第1行第1列。
  2. 棋子车当前位置为：第1行第4列。
  3. 棋子车当前位置为：第5行第4列。
  4. ******悔棋******
  5. 棋子车当前位置为：第1行第4列。
  6. ******悔棋******
  7. 棋子车当前位置为：第1行第1列。
  8. ******撤销悔棋******
  9. 棋子车当前位置为：第1行第4列。
  10. ******撤销悔棋******
  11. 棋子车当前位置为：第5行第4列。

扩展

本实例只能实现最简单的Undo和Redo操作，并未考虑对象状态在操作过程中出现分支的情况。如果在撤销到某个历史状态之后，用户再修改对象状态，此后执行Undo操作时可能会发生对象状态错误，大家可以思考其产生原因。【注：可将对象状态的改变绘制成一张树状图进行分析。】

在实际开发中，可以使用链表或者堆栈来处理有分支的对象状态改变，大家可通过链表或者堆栈对上述实例进行改进。