2023/10/21 每日总结

今天完成了设计模式实验16

实验16：命令模式

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

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

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

 

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

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

类图

 

源代码

package org.test16;

public class AddCommand implements Command{
    private Receiver receiver;
    private int value;

    public AddCommand(Receiver receiver, int value) {
        this.receiver = receiver;
        this.value = value;
    }

    @Override
    public void execute() {
        receiver.addValue(value);
    }

    @Override
    public void undo() {
        receiver.subtractValue(value);
    }
}



package org.test16;

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class CareTaker {
    private List<Stack<Command>> history = new LinkedList<>();

    public void saveState(Stack<Command> state) {
        history.add(state);
    }

    public Stack<Command> getState(int index) {
        return history.get(index);
    }

}




package org.test16;

public class Client {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Invoker invoker = new Invoker();


        // 执行一系列加法操作
        invoker.executeCommand(new AddCommand(receiver, 5));
        invoker.executeCommand(new AddCommand(receiver, 10));
        invoker.executeCommand(new AddCommand(receiver, 8));

        // 保存当前状态
        //careTaker.saveState(invoker.getRedoStack());

        // 撤销一次
        invoker.undo();

        // 保存当前状态
        //careTaker.saveState(invoker.getUndoStack());

        // 重做一次
        invoker.redo();

        // 撤销一次
        invoker.undo();
    }
}




package org.test16;

public interface Command {
    void execute();
    void undo();
}



package org.test16;

import java.util.Stack;

public class Invoker {
    private Stack<Command> undoStack = new Stack<>();
    private Stack<Command> redoStack = new Stack<>();

    public void executeCommand(Command command) {
        command.execute();
        undoStack.push(command);
        redoStack.clear();
    }

    public void undo() {
        if (!undoStack.isEmpty()) {
            Command command = undoStack.pop();
            command.undo();
            redoStack.push(command);
        } else {
            System.out.println("Nothing to undo.");
        }
    }
    public Stack<Command> getUndoStack() {
        return undoStack;
    }
    public Stack<Command> getRedoStack() {
        return redoStack;
    }

    public void redo() {
        if (!redoStack.isEmpty()) {
            Command command = redoStack.pop();
            command.execute();
            undoStack.push(command);
        } else {
            System.out.println("Nothing to redo.");
        }
    }
}




package org.test16;

public class Receiver {
    private int value = 0;

    public void addValue(int amount) {
        value += amount;
        System.out.println("Value after addition: " + value);
    }

    public void subtractValue(int amount) {
        value -= amount;
        System.out.println("Value after subtraction: " + value);
    }

    public int getValue() {
        return value;
    }

}