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();
}
}
当我们运行以上代码时，控制台将会输出：
厨师正在烹饪订单...
服务员正在上菜...
收银员正在取消订单...
这个例子中，顾客点餐后，服务员将不同的订单给相应的接收者（厨师、服务员和收银员），通过简单命令模式实现了对不同操作的封装和执行。
