命令模式实现简易计算器

最新推荐文章于 2024-10-23 20:25:41 发布

财大彭于晏

最新推荐文章于 2024-10-23 20:25:41 发布

阅读量389

点赞数 2

文章标签：命令模式 java

本文链接：https://blog.youkuaiyun.com/wojadhi/article/details/137877055

版权

文章介绍了如何使用CommandPattern设计一个支持多次撤销和恢复的简易计算器，通过创建抽象命令类和具体命令类，实现在计算器界面上执行加法运算并能进行前后操作的回退与重做。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题

Sunny软件公司欲开发一个简易计算器，该计算器可以实现简单的数学运算，还可以对运算实施撤销操作。修改简易计算器源代码，使之能够实现多次撤销(Undo)和恢复(Redo)。

package com.liyajie.Pattern.CommandPattern;

import java.util.LinkedList;

//加法类：请求接收者
class Adder {
    private int num = 0; //定义初始值为0

    //加法操作，每次将传入的值与num作加法运算，再将结果返回
    public int add(int value) {
        num += value;
        return num;
    }
}

//抽象命令类
abstract class AbstractCommand {
    public abstract int execute(int value); //声明命令执行方法execute()

    public abstract int undo(); //声明撤销方法undo()
	public abstract int redo(); //声明重做方法
}

//具体命令类
class ConcreteCommand extends AbstractCommand {
    private Adder adder = new Adder();
    private int value;

    private LinkedList<Integer> undoList = new LinkedList<>();
	private LinkedList<Integer> redoList = new LinkedList<>();

    //实现抽象命令类中声明的execute()方法，调用加法类的加法操作
    public int execute(int value) {
        this.value = value;
		undoList.add(value);
        return adder.add(value);
    }

    //实现抽象命令类中声明的undo()方法，通过加一个相反数来实现加法的逆向操作
    public int undo() {
        int undoValue = 0;
        if (undoList.size() == 0) {
			System.out.println("已到达最开始");
			return value;
        }
		undoValue = undoList.removeLast();
		redoList.add(undoValue);
		this.value = adder.add(-undoValue);
		return value;
    }

	@Override
	public int redo() {
		int redoValue = 0;
		if (redoList.size()==0){
			System.out.println("已恢复到最后");
			return value;
		}
		redoValue = redoList.removeLast();
		this.value = adder.add(redoValue);
		return value;
	}
}

//计算器界面类：请求发送者
class CalculatorForm {
    private AbstractCommand command;

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

    //调用命令对象的execute()方法执行运算
    public void compute(int value) {
        int i = command.execute(value);
        System.out.println("执行运算，运算结果为：" + i);
    }

    //调用命令对象的undo()方法执行撤销
    public void undo() {
        int i = command.undo();
        System.out.println("执行撤销，运算结果为：" + i);
    }
	public void redo(){
		int i = command.redo();
		System.out.println("执行恢复，运算结果为：" + i);
	}
}

class Test {
    public static void main(String args[]) {
        CalculatorForm form = new CalculatorForm();
        AbstractCommand command;
        command = new ConcreteCommand();
        form.setCommand(command); //向发送者注入命令对象

        form.compute(10);
        form.compute(5);
        form.compute(10);
        form.undo();
        form.undo();
        form.undo();
		form.undo();
		form.redo();
		form.redo();
		form.redo();
		form.redo();
		form.redo();
    }
}

执行结果

执行运算，运算结果为：10
执行运算，运算结果为：15
执行运算，运算结果为：25
执行撤销，运算结果为：15
执行撤销，运算结果为：10
执行撤销，运算结果为：0
已到达最开始
执行撤销，运算结果为：0
执行恢复，运算结果为：10
执行恢复，运算结果为：15
执行恢复，运算结果为：25
已重做到最后
执行恢复，运算结果为：25
已重做到最后
执行恢复，运算结果为：25