GPT带我学-设计模式-命令模式

1 你知道设计模式的命令模式吗

是的，我知道设计模式中的命令模式。命令模式是一种行为型设计模式，它将请求封装成一个对象，从而允许使用不同的请求、队列或日志来参数化其他对象。命令模式还支持撤销操作，并且可以提供事务的实现。

在命令模式中，有四个主要的参与对象：命令接口（Command）、具体命令（ConcreteCommand）、命令发起者（Invoker）和命令执行者（Receiver）。命令接口充当了命令的抽象，并声明了执行命令的方法。具体命令实现了命令接口，并具体实现了命令的执行逻辑。命令发起者持有一个命令对象，并可以调用命令对象的执行方法，从而触发命令的执行。命令执行者实际执行命令的操作。

命令模式的优点包括：解耦命令发起者和命令执行者、简化命令的撤销和重做、支持事务等。它可以帮助我们将请求和执行解耦，并且可以提供更好的灵活性和可扩展性。

2 命令模式有几种形式

命令模式主要有三种形式：简单命令模式、宏命令模式和撤销操作命令模式。

简单命令模式（Simple Command Pattern）：简单命令模式是命令模式最基本的形式。它只包含一个命令接口和多个具体命令类。每个具体命令类都实现了命令接口，并实现了自己的执行逻辑。命令发起者只需要持有一个命令接口的引用，并通过调用命令接口的方法来触发命令的执行。

宏命令模式（Macro Command Pattern）：宏命令模式将多个命令封装为一个宏命令，从而实现一次性执行多个命令。宏命令本身也是一个具体命令，它持有多个其他具体命令的引用，并在执行时依次调用这些命令的执行方法。宏命令模式可以将多个原子操作组合成一个更高级的操作。

撤销操作命令模式（Undo Command Pattern）：撤销操作命令模式在简单命令模式的基础上加入了撤销操作的支持。每个具体命令类都需要提供一个撤销方法，在调用撤销方法时可以回滚该命令的执行。撤销操作命令模式可以用于实现撤销和重做功能，使得用户可以取消一系列操作的执行。

这些形式不是互斥的，可以根据具体的需求和场景选择适合的命令模式形式。

3 请你用java写一个简单命令模式具体的例子

当然可以！下面是一个简单的Java代码示例，演示了简单命令模式的实现：

// 定义命令接口
interface Command {
    void execute();
}

// 具体命令类
class ConcreteCommand implements Command {
    private Receiver receiver;
    
    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    
    // 实现命令接口的执行方法
    public void execute() {
        receiver.action();
    }
}

// 接收者类
class Receiver {
    public void action() {
        System.out.println("Receiver执行命令！");
    }
}

// 命令发起者类
class Invoker {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void executeCommand() {
        command.execute();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建接收者对象
        Receiver receiver = new Receiver();
        
        // 创建具体命令对象，并将接收者传递给它
        Command command = new ConcreteCommand(receiver);
        
        // 创建命令发起者对象，并设置命令对象
        Invoker invoker = new Invoker();
        invoker.setCommand(command);
        
        // 执行命令
        invoker.executeCommand();
    }
}

在上面的示例中，Command接口定义了命令的执行方法execute()。具体命令类ConcreteCommand实现了Command接口，并在execute()方法中调用了接收者对象的action()方法执行具体的命令操作。命令发起者类Invoker持有一个Command对象，并在executeCommand()方法中调用命令对象的execute()方法来触发命令的执行。

运行以上代码，输出结果为：

Receiver执行命令！

这表明成功执行了命令模式，命令发起者通过调用命令对象的方法，将命令传递给接收者并执行了相关操作。

4 你这个例子还是太抽象了，请举一个生活中具体的例子

当然！让我们来看一个更具生活化的例子——简单命令模式在餐厅点餐系统中的应用。

首先，我们定义一个命令接口Order，其中包含了一个执行命令的方法execute()：

public interface Order {
    void execute();
}

然后，我们实现具体的命令类，比如CookOrder、ServeOrder和CancelOrder：

public class CookOrder implements Order {
    private Chef chef;
    
    public CookOrder(Chef chef) {
        this.chef = chef;
    }
    
    public void execute() {
        chef.cook();
    }
}

public class ServeOrder implements Order {
    private Waiter waiter;
    
    public ServeOrder(Waiter waiter) {
        this.waiter = waiter;
    }
    
    public void execute() {
        waiter.serve();
    }
}

public class CancelOrder implements Order {
    private Cashier cashier;
    
    public CancelOrder(Cashier cashier) {
        this.cashier = cashier;
    }
    
    public void execute() {
        cashier.cancel();
    }
}

在这个例子中，CookOrder是具体的烹饪命令，ServeOrder是具体的上菜命令，CancelOrder是具体的取消订单命令。

接下来，我们定义几个接收者类，比如Chef、Waiter和Cashier，它们都具有相应的操作：

public class Chef {
    public void cook() {
        System.out.println("厨师正在烹饪订单...");
    }
}

public class Waiter {
    public void serve() {
        System.out.println("服务员正在上菜...");
    }
}

public class Cashier {
    public void cancel() {
        System.out.println("收银员正在取消订单...");
    }
}

最后，我们定义命令发起者类OrderInvoker，它持有一个Order对象，并在调用execute()方法时触发命令的执行：

public class OrderInvoker {
    private Order order;
    
    public OrderInvoker(Order order) {
        this.order = order;
    }
    
    public void executeOrder() {
        order.execute();
    }
}

现在，我们可以使用上述类来模拟餐厅点餐的场景。例如，在点餐系统中，当一个顾客确定要点餐后，服务员会将顾客的订单交给厨师，并通知收银员进行结算

public class RestaurantClient {
    public static void main(String[] args) {
        Chef chef = new Chef();
        Waiter waiter = new Waiter();
        Cashier cashier = new Cashier();
        
        Order cookOrder = new CookOrder(chef);
        Order serveOrder = new ServeOrder(waiter);
        Order cancelOrder = new CancelOrder(cashier);
        
        OrderInvoker invoker = new OrderInvoker(cookOrder);
        invoker.executeOrder();
        
        invoker = new OrderInvoker(serveOrder);
        invoker.executeOrder();
        
        invoker = new OrderInvoker(cancelOrder);
        invoker.executeOrder();
    }
}

当我们运行以上代码时，控制台将会输出：

厨师正在烹饪订单...
服务员正在上菜...
收银员正在取消订单...

这个例子中，顾客点餐后，服务员将不同的订单给相应的接收者（厨师、服务员和收银员），通过简单命令模式实现了对不同操作的封装和执行。