java design pattern - command pattern

这个command pattern 貌似用处还挺多的，而且也算是比教复杂的pattern 了，anyway ,直接上代码。 

一个简单的代码如下：

package CommandPattern;

//Command interface with an execute() method

interface Command{
    public void execute();
}

//Lunch is a receiver
class Lunch{
    public void makeLunch(){
        System.out.println("Lunch is being made");
    }
}

//LunchCommand implements Command, it contains a reference to Lunch,a receiver
// Its execute() method invokes the appropriate action on the receiver

class LunchCommand implements Command{
    Lunch lunch;


    public LunchCommand(Lunch lunch){
        this.lunch = lunch;
    }

    @Override
    public void execute(){
        lunch.makeLunch();
    }
}

//Dinner is also receiver
class Dinner{
    public void makeDinner(){
        System.out.println("Dinner is being made");
    }
}


/* The DinnerCommand is similar to LunchCommand.
 * it contains a reference to Dinner, a receiver.
 * Its execute() method invokes the makeDinner() action of the Dinner object
 */

class DinnerCommand implements Command{
    Dinner dinner;

    public DinnerCommand(Dinner dinner){
        this.dinner = dinner;
    }

    @Override
    public void execute(){
        dinner.makeDinner();
    }
}

/* MealInvoker is the invoker class, it contains a reference to the Command
 * to invoke . Its invoke() method calls the execute() method of the Command
 */

class MealInvoker{
    Command command;

    public MealInvoker(Command command){
        this.command = command;
    }

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

    public void invoke(){
        command.execute();
    }
}


public class CommandPatternDemo {
    public static void main(String[] args){
        Lunch lunch = new Lunch();    //receiver
        Command lunchCommand = new LunchCommand(lunch);        //concrete command

        Dinner dinner = new Dinner();
        Command dinnerCommand = new DinnerCommand(dinner);        //concrete command

        MealInvoker mi = new MealInvoker(lunchCommand);        //invoker
        mi.invoke();

        mi.setCommand(dinnerCommand);
        mi.invoke();
    }
}

下面这个要稍微复杂些了
参考了这个代码： 

package CommandPattern;

interface MyCommand{
    public void Execute();
    public void unExecute();
}

class Calculator{
    private int current;

    public Calculator(int current){
        this.current = current;
    }

    public void Action(String operator, int operand){
        switch(operator){
            case "+":
                this.current += operand;
                break;
            case "-":
                this.current -= operand;
                break;
            case "*":
                this.current *= operand;
                break;
            case "/":
                this.current /= operand;
                break;
        }
    }

    public int getCurrent(){
        return this.current;
    }
}


class concreteCommand implements MyCommand{
    protected String operator ;
    protected int operand;
    protected int _lastnum;
    Calculator cal;


    public concreteCommand(String operator,int operand, Calculator cal,int _lastnum){
        this.operand = operand;
        this.operator = operator;
        this.cal = cal;
        this._lastnum = _lastnum;
    }

    public void Execute(){
        cal.Action(operator, operand);
    }

    public void unExecute(){
        cal.Action(Undo(operator), operand);
    }

    private String Undo(String operator){
        switch(operator){
            case "+": return "-" ;
            case "-": return "+" ;
            case "*": return "/" ;
            case "/": return "*" ;
            default:
                System.out.println("wrong operand");
                return null;
        }
    }
}

class CalInvoker {
    MyCommand command;

    public CalInvoker(MyCommand command){
        this.command = command;
    }

    public void setInvoker(MyCommand command){
        this.command = command;
    }

    public void Invoke(){
        command.Execute();
    }

    public void unInvoke(){
        command.unExecute();
    }
}

public class CommandPatternDemo2 {
    public static void main(String[] args){


        Calculator ca = new Calculator(0);
        MyCommand cm1 = new concreteCommand("+",5,ca,0);

        CalInvoker ci = new CalInvoker(cm1);
        ci.Invoke();
        System.out.println(ca.getCurrent());
        ci.unInvoke();
        System.out.println(ca.getCurrent());
    }
}