某系統需要提供一個命令集合（注：可以使用連結串列，棧等集合物件實現），用於儲存一系列命令物件，並通過該命令集合實現多次undo()和redo()操作，可以使用加法運算來模擬實現。

package com;
//抽象命令類
public abstract class AbstractCommand {
    public abstract int execute(int value);
    public abstract int undo();
    public abstract int redo();
}

package com;
//請求接受者
public class Adder {
    
 
private int num=0;
    public int add(int value){

        num+=value;
        return num;
    }
}

package com;
//具體命令類
public class ConcreteCommand extends AbstractCommand{
    private int[] a=new int[50];
    private int i=0;

    private Adder adder=new Adder();
    private int value;

    @Override
    
 
public int execute(int value) {

            this.value = value;
            a[i] = value;
            i++;
            return adder.add(value);

    }

    @Override
    public int undo() {
       if(i-->=0)
       {    i--;
        return adder.add(-a[i]);}
       else
       {
           System.out.println(
 
"不能撤銷了o~");
           return adder.add(0);
       }
    }

    @Override
    public int redo() {
        i++;
        return adder.add(a[i-1]);
    }
}

package com;

public class CalculatorForm {
    private AbstractCommand command;
    public void setCommand(AbstractCommand command){
        this.command=command;
    }
    public void computer(int value){
        int i=command.execute(value);
        System.out.println("執行運算，運算結果為："+i);
    }
    public void undo(){
        int i=command.undo();
        System.out.println("執行撤銷，運算結果為："+i);
    }
    public void redo(){
        int i=command.redo();
        System.out.println("取消撤銷，運算結果為："+i);
    }
}

客戶端

package com;

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

        AbstractCommand command;
        command=new ConcreteCommand();//重構這行程式碼，可以更換具體命令類
        form.setCommand(command);

        form.computer(10);
        form.computer(5);
        form.undo();
        form.undo();
        form.redo();
        form.computer(3);
    }
}

執行結果