将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开，委派给不同的对象执行。

    命令模式可以将请求发送者和接收者完全解耦，发送者与接收者之间没有直接引用关系，发送请求的对象只需要知道如何发送请求，而不必知道如何完成请求。

    【角色】

    • 命令角色（Command ）：一个具体命令的抽象接口。
    • 命令角色实现类（ConcreteCommand）：具体命令本身并不实现具体的业务命令，而是会将调用委派给一个业务逻辑对象(命令接收者)去执行。
    • 接收者角色（Receiver）：命令传递到这里执行对应的操作。

    • 调用者角色（Invoker）：接收到命令，并执行命令，也就是命令的发动者和调用者。

      1. /**
      2. * 工作人员（接收者角色）
      3. */
      4. public abstract class Worker {
      5.   /**
      6.    * 工作内容
      7.    */
      8.   public abstract void action();
      9. }
      1. /**
      2. * 厨师
      3. */
      4. public class CookWorker extends Worker{
      5.   @Override
      6.   public void action() {
      7.       System.out.println("厨师准备炒菜");
      8.   }
      9. }
      1. /**
      2. * 吧台
      3. */
      4. public class CounterWorker extends Worker{
      5.   @Override
      6.   public void action() {
      7.       System.out.println("吧台准备酒水");
      8.   }
      9. }
      1. /**
      2. * 下单（命令角色）
      3. */
      4. public abstract class Order {
      6.   protected Worker worker;
      8.   public Order(Worker worker) {
      9.       this.worker = worker;
      10.   }
      12.   /**
      13.    * 点餐
      14.    */
      15.   public abstract void need();
      16. }
      1. /**
      2. * 饭菜下单（命令角色实现类）
      3. */
      4. public class MealOrder extends Order {
      6.   public MealOrder(Worker worker) {
      7.       super(worker);
      8.   }
      10.   @Override
      11.   public void need() {
      12.       System.out.println("来一份小炒肉");
      13.       worker.action();
      14.   }
      15. }
      1. /**
      2. * 酒水下单（命令角色实现类）
      3. */
      4. public class DrinksOrder extends Order {
      6.   public DrinksOrder(Worker worker) {
      7.       super(worker);
      8.   }
      10.   @Override
      11.   public void need() {
      12.       System.out.println("来一瓶雪碧");
      13.       worker.action();
      14.   }
      15. }
      1. /**
      2. * 服务员（调用者角色）
      3. */
      4. public class Waiter {
      6.   private Order order;
      8.   public void setOrder(Order order) {
      9.       this.order = order;
      10.   }
      12.   /**
      13.    * 通知后厨
      14.    */
      15.   public void call() {
      16.       System.out.println("收到客户下单，通知后厨....");
      17.       order.need();
      18.   }
      19. }

      ```java public class CommandTest { public static void main(String[] args) {

      1.   // 工作人员（命令接收者）
      2.   Worker cookWorker = new CookWorker();
      3.   Worker counterWorker = new CounterWorker();
      4.   // 下单（命令）
      5.   Order mealOrder = new MealOrder(cookWorker);
      6.   Order drinksOrder = new DrinksOrder(counterWorker);
      7.   // 服务员（命令调用者）
      8.   Waiter waiter = new Waiter();
      9.   waiter.setOrder(mealOrder);
      10.   waiter.call();
      12.   System.out.println();
      14.   waiter.setOrder(drinksOrder);
      15.   waiter.call();

      } } ——输出—— 收到客户下单，通知后厨…. 来一份小炒肉 厨师准备炒菜

    收到客户下单，通知后厨…. 来一瓶雪碧 吧台准备酒水 ```