命令模式——java实现 - 戈瑾

问题描述：

某系统需要提供一个命令集合（注：可以使用链表，栈等集合对象实现），用于存储一系列命令对象，并通过该命令集合实现多次undo()和redo()操作，可以使用加法运算来模拟实现。
类图：

java代码：

  1 //Invoker.java
  2 package shiyan16;
  3 
  4 public class Invoker {
  5     private Command command;
  6     public void setCommand(Command command) {
  7         this.command =command;
  8     }
  9     /**
 10      * 执行运算
 11      * @param value
 12      */
 13     public void addNum(int value) {
 14         command.execute(value);
 15     }
 16     /**
 17      * 撤回
 18      */
 19     public void undo() {
 20         int i = command.undo();
 21         if(i==-1){
 22             System.out.println("已撤销到初态");
 23         }else{
 24             System.out.println("执行成功，运算结果是："+i);
 25         }
 26     }
 27     /**
 28      * 恢复
 29      */
 30     public void redo() {
 31          int i = command.redo();
 32         if(i==-1){
 33             System.out.println("已重复到终态");
 34         }
 35         else{
 36             System.out.println("执行成功，运算结果是："+i);
 37         }
 38     }
 39 }
 40 //Command.java
 41 package shiyan16;
 42 
 43 public abstract class Command {
 44       public abstract int execute(int value);
 45       public abstract int undo();
 46       public abstract int redo();
 47 }
 48 //Adder.java
 49 package shiyan16;
 50 
 51 public class Adder {
 52      private int num =0;
 53      public int addOperate(int value) {
 54          num+=value;
 55          return num;
 56      }
 57 }
 58 //AddCommand.java
 59 package shiyan16;
 60 
 61 import java.util.Stack;
 62 
 63 public class AddCommand extends Command{
 64      private Adder adder = new Adder();
 65      private Stack<Integer> unStack = new Stack<Integer>();// 撤回栈，用来记录所做的每一步操作，用于撤回
 66      private Stack<Integer> reStack = new Stack<Integer>();// 恢复栈，用来存储返回栈弹出的数据，用于恢复
 67 
 68      /**
 69       * 撤回
 70       */
 71      
 72      public int undo() {
 73          int i=0;
 74          if (unStack.isEmpty()) {         
 75              i=-1;
 76          }else{
 77              Integer pop = unStack.pop();
 78              reStack.push(pop);   //将撤回栈中的栈顶元素弹出，并且压入恢复栈中
 79              if(!unStack.isEmpty()){//判断弹出数据后是否为空，如果为空，说明已撤回到最原始状态
 80                  i=unStack.peek();
 81              }
 82          }
 83          return i;
 84      }
 85 
 86      /**
 87       * 恢复
 88       */
 89      public int redo() {
 90          int i=0;
 91          if (reStack.isEmpty()) {
 92              i=-1;
 93          }else{//撤回时只要可以可以撤回，则撤回栈一定有数据
 94              Integer pop = reStack.pop();
 95              unStack.push(pop);
 96              i=pop;
 97          }
 98          return i;
 99      }
100 
101      /**
102       * 执行计算，并进行栈的更新
103       */
104      public int execute(int value) {
105          int v = 0;
106          v = adder.addOperate(value);
107          System.out.println(v);
108          unStack.push(v);
109          return v;
110      }
111 }
112 //Client.java
113 package shiyan16;
114 public class Client {
115     public static void main(String[] args) {
116         Invoker inv = new Invoker();
117         AddCommand command = new AddCommand();
118         inv.setCommand(command);
119         //计算
120         System.out.println("计算过程:");
121         inv.addNum(1);
122         inv.addNum(2);
123         inv.addNum(3);
124         //多次撤回
125         System.out.println("undo操作:");
126         inv.undo();
127         inv.undo();
128         inv.undo();
129         inv.undo();
130         //多次恢复
131         System.out.println("redo操作:");
132         inv.redo();
133         inv.redo();
134         inv.redo();
135         inv.redo();
136     }
137 }
运行结果：

posted on 2021-11-03 08:55 戈瑾阅读(80) 评论(0) 收藏举报
刷新页面返回顶部