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

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

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

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

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

实验要求：

1. 提交类图；

2. 提交源代码；

3. 注意编程规范。

1、类图

源代码

package org.example;

import java.util.Stack;
public abstract class AbstractCommand {
    public abstract int execute(int value);
    public abstract int undo();
    public abstract int redo();
}

package org.example;

// 具体的加法命令
public class AddCommand implements Command {
    private int value;
    private Calculator calculator;

    public AddCommand(Calculator calculator, int value) {
        this.calculator = calculator;
        this.value = value;
    }

    @Override
    public void execute() {
        calculator.add(value);
    }

    @Override
    public void undo() {
        calculator.add(-value); // 撤销操作，执行反向加法
    }
}

package org.example;

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

package org.example;

// 计算器类
public class Calculator {
    private int total = 0;

    public void add(int value) {
        total += value;
    }

    public int getTotal() {
        return total;
    }
}

package org.example;

import java.util.Stack;

public class CalculatorForm {
    private Command currentCommand;
    private Stack<Command> undoStack = new Stack<>();
    private Stack<Command> redoStack = new Stack<>();
    private Calculator calculator = new Calculator();

    // 设置当前命令
    public void setCommand(Command command) {
        this.currentCommand = command;
    }

    // 执行计算
    public void compute(int value) {
        AddCommand command = new AddCommand(calculator, value);
        command.execute();  // 执行加法
        System.out.println("计算结果: " + calculator.getTotal());
        undoStack.push(command);  // 将命令添加到撤销栈
        redoStack.clear();  // 清空重做栈
    }

    // 撤销操作
    public void undo() {
        if (!undoStack.isEmpty()) {
            Command command = undoStack.pop();
            command.undo();  // 执行撤销操作
            redoStack.push(command);  // 将命令推到重做栈
            System.out.println("撤销后结果: " + calculator.getTotal());
        } else {
            System.out.println("没有可以撤销的操作!");
        }
    }

    // 恢复操作
    public void redo() {
        if (!redoStack.isEmpty()) {
            Command command = redoStack.pop();
            command.execute();  // 执行重做操作
            undoStack.push(command);  // 将命令推到撤销栈
            System.out.println("恢复后结果: " + calculator.getTotal());
        } else {
            System.out.println("没有可以重做的操作!");
        }
    }
}

package org.example;

public class Client {
    public static void main(String[] args) {
        CalculatorForm form = new CalculatorForm();

        // 进行计算
        System.out.println("------计算过程------");
        form.compute(1); // 结果: 1
        form.compute(2); // 结果: 3
        form.compute(3); // 结果: 6
        form.compute(4); // 结果: 10

        // 多次撤回
        System.out.println("------撤回过程------");
        form.undo(); // 结果: 6
        form.undo(); // 结果: 3
        form.undo(); // 结果: 1
        form.undo(); // 结果: 0
        form.undo(); // 没有可以撤销的操作

        // 多次恢复
        System.out.println("------恢复过程------");
        form.redo(); // 结果: 1
        form.redo(); // 结果: 3
        form.redo(); // 结果: 6
        form.redo(); // 结果: 10
        form.redo(); // 没有可以重做的操作
    }
}

package org.example;

// 命令接口
public interface Command {
    void execute();
    void undo();
}

3、运行截图