实验16：命令模式

[实验任务一]：多次撤销和重复的命令模式

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

实验要求：

1. 提交类图；

2. 提交源代码；

3. 注意编程规范。

1.类图

 

 2.源代码

//AbstractCommand.java
package test16;
import java.util.Stack;

public abstract class AbstractCommand {
    public abstract int execute(int value);
    public abstract int undo();
    public abstract int redo();
}

//AddCommand .java
public class AddCommand extends AbstractCommand {
      private Adder adder = new Adder();
      private Stack<Integer> unStack = new Stack<Integer>();// 返回栈，用来记录所做的每一步操作，用于撤回
      private Stack<Integer> reStack = new Stack<Integer>();// 重复栈，用来存储返回栈弹出的数据，由于重复
    //撤回
     public int undo() {
         int i=0;
         if (unStack.isEmpty()) {
             
             i=-1;
         }else{
             Integer pop = unStack.pop();
             reStack.push(pop);
             if(!unStack.isEmpty()){//判断弹出数据后是否为空，如果为空，说明已撤回到最原始状态
                 i=unStack.peek();
             }
         }
         return i;
     }
 
    //恢复
     public int redo() {
         int i=0;
         if (reStack.isEmpty()) {
             i=-1;
         }else{//撤回时只要可以可以撤回，则返回栈一定有数据
             Integer pop = reStack.pop();
             unStack.push(pop);
             i=pop;
         }
         return i;
     }
 
     //更新栈
     public int execute(int value) {
         int v = 0;
         if (unStack.isEmpty()) {// 说明还没有数据
             v = adder.add(value);
             unStack.push(v);
         } else {// 需要更新两个栈中的内容，并计算结果,其中返回栈应该更新，重复栈应该清空
             v = adder.add(value);
             unStack.push(v);
             if (!reStack.isEmpty()) {
                 for (int i = 0; i < reStack.size(); i++) {
                     reStack.pop();
                 }
             }
         }
         return v;
     }
 }

//Adder.java
public class Adder {
     private int num =0;
     public int add(int value) {
        num+=value;
        return num;
     }
}

//CalculatorForm.java
public class CalculatorForm {
          private AbstractCommand command;
          public void setCommand(AbstractCommand command) {
              this.command =command;
          }
          /**
               * 执行运算
           * @param value
           */
         public void compute(int value) {
             command.execute(value);
         }
         /**
              * 撤回
          */
         public void undo() {
             int i = command.undo();
             if(i==-1){
                 System.out.println("缓存中已不存在数据");
             }else{
                 System.out.println("执行成功，运算结果是："+i);
             }
         }
         /**
          * 恢复
          */
         public void redo() {
              int i = command.redo();
             if(i==-1){
                 System.out.println("已恢复至最新数据");
             }
             else{
                 System.out.println("执行成功，运算结果是："+i);
             }
         }
     }

//Client.java
public class Client {
    public static void main(String[] args) {
        CalculatorForm form = new CalculatorForm();
        AddCommand command = new AddCommand();
        form.setCommand(command);
        //计算
        System.out.println("------计算过程------");
        form.compute(1);
        form.compute(2);
        form.compute(3);
        form.compute(4);
        //多次撤回
        System.out.println("------撤回过程------");
        form.undo();
        form.undo();
        form.undo();
        form.undo();
        form.undo();
        //多次恢复
        System.out.println("------恢复过程------");
        form.redo();
        form.redo();
        form.redo();
        form.redo();
        form.redo();    
    }
}

运行截图