10.23每日总结

软件设计                  石家庄铁道大学信息学院

 

实验16：命令模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容： 

1、理解命令模式的动机，掌握该模式的结构；

2、能够利用命令模式解决实际问题。

 

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

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

实验要求：

 

 

package sixteen;

 

import java.util.Stack;

 

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;

   }

}

package sixteen;

import java.util.Stack;

public abstract class AbstractCommand {

    public abstract int execute(int value);

    public abstract int undo();

    public abstract int redo();

}

package sixteen;

 

import java.util.Stack;

 

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;

   }

}

package sixteen;

 

public class Adder {

    private int num =0;

    public int add(int value) {

       num+=value;

       return num;

    }

}

package sixteen;

 

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);

       }

   }

}