设计模式(016)行为型之命令模式

        命令模式，它将请求封装成一个对象，从而允许客户端参数化操作队列、记录请求日志、支持撤销操作等。在命令模式中，有四个核心角色：命令接口（Command）、具体命令（ConcreteCommand）、调用者（Invoker）、接收者（Receiver）。
① 命令接口（Command）：声明了执行命令的方法，是命令对象的抽象表示。
② 具体命令（ConcreteCommand）：实现了命令接口，具体定义了要执行的操作。
③ 调用者（Invoker）：负责调用命令对象执行请求，它并不知道具体的命令细节，只知道调用命令对象的方法来完成请求。
④ 接收者（Receiver）：负责实际执行命令指定的操作。
命令模式的核心思想是将请求的发送者与请求的接收者解耦，通过命令对象将二者进行绑定。这样可以实现对请求的封装、记录、排队和撤销操作等功能。

1、场景设计

实现场景：请求者发出命令，接收者接收命令并执行一个动作。

2、C++实现

`Command` 是命令接口，定义了一个纯虚的 `execute()` 方法。`ConcreteCommand` 是具体命令，实现了 `Command` 接口，并在 `execute()` 方法中调用了接收者的 `action()` 方法。`Receiver` 是接收者，负责实际执行命令指定的操作。`Invoker` 是调用者，负责维护一系列命令，并负责调用这些命令执行请求。在 `main()` 函数中，我们创建了一个接收者、一个具体命令和一个调用者，并将具体命令添加到调用者中执行。

#include <iostream>
#include <vector>

// 命令接口
class Command {
    public:
        virtual void execute() = 0;
};

// 接收者
class Receiver {
    public:
        void action() {
            std::cout << "Receiver: Executing action" << std::endl;
        }
};

// 具体命令
class ConcreteCommand : public Command {
    private:
        class Receiver *receiver;

    public:
        ConcreteCommand(class Receiver *recv) : receiver(recv) {}

        void execute() override {
            receiver->action();
        }
};

// 调用者
class Invoker {
    private:
        std::vector<Command *> commands;

    public:
        void addCommand(Command *cmd) {
            commands.push_back(cmd);
        }

        void executeCommands() {
            for (Command *cmd : commands) {
                cmd->execute();
            }
            commands.clear();
        }
};

int main() {
    Receiver *receiver = new Receiver();
    Command *command = new ConcreteCommand(receiver);
    Invoker *invoker = new Invoker();

    invoker->addCommand(command);
    invoker->executeCommands();

    delete receiver;
    delete command;
    delete invoker;

    return 0;
}

3、Java实现

`Command` 是命令接口，定义了一个 `execute()` 方法。`ConcreteCommand` 是具体命令，实现了 `Command` 接口，并在 `execute()` 方法中调用了接收者的 `action()` 方法。`Receiver` 是接收者，负责实际执行命令指定的操作。`Invoker` 是调用者，负责调用命令对象执行请求。在 `main()` 方法中，我们创建了一个接收者、一个具体命令和一个调用者，并将具体命令绑定到调用者上执行。

package behavioralpattern.command;

public class CommandDemo {
    // 命令接口
    interface Command {
        void execute();
    }
    // 具体命令
    static class ConcreteCommand implements Command {
        private Receiver receiver;
        ConcreteCommand(Receiver receiver) {
            this.receiver = receiver;
        }
        @Override
        public void execute() {
            receiver.action();
        }
    }

    // 接收者
    static class Receiver {
        void action() {
            System.out.println("Receiver: Executing action");
        }
    }

    // 调用者
    static class Invoker {
        private Command command;
        void setCommand(Command command) {
            this.command = command;
        }
        void executeCommand() {
            command.execute();
        }
    }

    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();

        invoker.setCommand(command);
        invoker.executeCommand();
    }
}