每日总结

实验16：命令模式

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

AbstractCommand：

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

AddCommand：

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

Adder：

public class Adder {
    private int num = 0;

    public int add(int value) {
        num += value;
        return num;
    }
}

CalculatorForm：

public class CalculatorForm {
    private AbstractCommand command;

    public void setCommand(AddCommand 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：

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