20231120学习总结

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

public abstract class AbstractCommand {
    public abstract int valueOf(int value);
    public abstract int undo();

    public abstract int redo();
}

public class Adder {
    private int sum = 0;
    public int add(ArrayList<Integer> value){
        for(int i=0;i<value.size();)
        {
            sum += value.get(0);
            value.remove(0);
        }
        return sum;
    }
    public int reduce(ArrayList<Integer> value){
        for(int i=0;i<value.size();)
        {
            sum -= value.get(0);
            value.remove(0);
        }
        return sum;
    }
}

class CalculatorForm {//调用者
    private AbstractCommand command;

    public void setCommand(AbstractCommand command) {
        this.command=command;
    }

    //业务方法，用于调用命令类的方法
    public void compute(int value) {
        int i = command.valueOf(value);
        System.out.println("执行输入，输入命令为：" + value);
    }

    public void undo() {
        int i = command.undo();
        System.out.println("执行撤销，运算结果为：" + i);
    }

    public void redo() {
        int i = command.redo();
        System.out.println("执行运算，运算结果为：" + i);
    }
}

public class Command extends AbstractCommand{

    private Adder adder = new Adder();
    private ArrayList<Integer> value = new ArrayList<Integer>() ;
    @Override
    public int valueOf(int value) {
        this.value.add(value);
        return value;
    }

    @Override
    public int undo() {
        return adder.reduce(value);
    }

    @Override
    public int redo() {
        return adder.add(value);
    }
}

public class main {
    public static void main(String args[]) {
        CalculatorForm form = new CalculatorForm();
        Command command = new Command();
        form.setCommand(command);

        form.compute(1);
        form.redo();
        form.compute(2);
        form.compute(3);
        form.undo();

    }
}