两种语言实现设计模式（C++和Java）（十三：命令模式）

命令模式将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

实际上，命令模式就是实现请求和执行者之间的解耦。图中Invoker实现接受和管理各种命令，然后统一向Receiver发起请求，所有类型的请求封装在Command中。例如在餐厅点菜，只需要和Waiter说，而不用和做菜的人说。

 

C++ 实现：

#include <iostream>
#include <vector>

using namespace std;

class Cooker{
public:
    void cookBeef(){
        cout << "Cooker cook beef." << endl;
    }
    void cookChicken(){
        cout << "Cooker cook chicken" << endl;
    }
};

class Command{
protected:
    Cooker* cooker;
public:
    Command(Cooker* _cooker){
        cooker = _cooker;
    }
    virtual void executeCmd() = 0;
};

class CommandBeef:public Command{
public:
    CommandBeef(Cooker* _cooker):Command(_cooker){}
    void executeCmd(){
        cooker->cookBeef();
    }
};

class CommandChicken:public Command{
public:
    CommandChicken(Cooker* _cooker):Command(_cooker){}
    void executeCmd(){
        cooker->cookChicken();
    }
};

class Waiter{
private:
    vector<Command*> vec_cmd;
public:
    ~Waiter(){
        for(auto it=vec_cmd.begin(); it != vec_cmd.end(); it++){
            delete (*it);
        }
        vec_cmd.clear();
    }
    void add(Command* command){
        vec_cmd.push_back(command);
    }
    void remove(Command* command){
        auto it = find(vec_cmd.begin(), vec_cmd.end(), command);
        if (it != vec_cmd.end()){
            vec_cmd.erase(it);
        }
    }
    void subCmd(){
        for (auto it=vec_cmd.begin(); it != vec_cmd.end(); it++){
            (*it)->executeCmd();
        }
    }
};

int main()
{
    Waiter *waiter = new Waiter();
    Cooker *cooker = new Cooker();
    waiter->add(new CommandBeef(cooker));
    waiter->add(new CommandChicken(cooker));
    waiter->subCmd();
    delete waiter;
    delete cooker;
    return 0;
}

Java实现：

public class Cooker {

    public void cookBeef(){
        System.out.println("Cooker cook beef");
    }

    public void cookChicken(){
        System.out.println("Cooker cook chicken");
    }
}

public interface Command {

    public abstract void executeCmd();
}

public class CommandBeef implements Command {

    private Cooker cooker;

    public CommandBeef(Cooker cooker){
        this.cooker = cooker;
    }

    public void executeCmd() {
        cooker.cookBeef();
    }
}

public class CommandChicken implements Command{

    private Cooker cooker;

    public CommandChicken(Cooker cooker){
        this.cooker = cooker;
    }

    public void executeCmd(){
        cooker.cookChicken();
    }
}

public class Waiter {

    private List<Command> commandList;

    public Waiter(){
        commandList = new ArrayList<Command>();
    }

    public void add(Command command){
        this.commandList.add(command);
    }

    public void subCommand(){
        for (Command command:
             commandList) {
            command.executeCmd();
        }
    }
}

public class Main {

    public static void main(String[] args) {
        Cooker cooker = new Cooker();
        Command command1 = new CommandBeef(cooker);
        Command command2 = new CommandChicken(cooker);
        Waiter waiter = new Waiter();
        waiter.add(command1);
        waiter.add(command2);
        waiter.subCommand();
    }

}