基本介绍：
    1、 命令模式（Command Pattern）：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计。
    2、命令模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。
    3、在命令模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求(即命令)，同时命令模式也支持可撤销的操作。
    4、 通俗易懂的理解：将军发布命令，士兵去执行。其中有几个角色：将军（命令发布者）、士兵（命令的具体执行者）、命令(连接将军和士兵)。
    Invoker 是调用者（将军），Receiver 是被调用者（士兵），MyCommand 是命令，实现了 Command 接口，持有接收对象

    UML类图：
    image.png

    命令模式的角色及职责：
    1、Invoker：调用者
    2、Command：命令，包含需要执行的所有命令，可以是接口或抽象类
    3、Receiver：接受者，知道如何实施和执行一个请求相关的操作
    4、ConcreteCommand：将一个接受者对象与一个动作，调用接受者相应的操作，实现execute

    代码示例：

    1. /**
    2.  * 命令接口
    3.  */
    4. public interface Command {
    6.     /**
    7.      * 执行命令
    8.      */
    9.     void execute();
    11.     /**
    12.      * 撤销命令
    13.      */
    14.     void undo();
    15. }
    18. /**
    19.  * 灯的开关
    20.  */
    21. public class LightReceiver {
    23.     public void lightOn(){
    24.         System.out.println("开灯");
    25.     }
    27.     public void lightOff(){
    28.         System.out.println("关灯");
    29.     }
    30. }
    33. public class LightOnCommand implements Command {
    35.     LightReceiver lightReceiver;
    37.     public LightOnCommand(LightReceiver lightReceiver){
    38.         this.lightReceiver = lightReceiver;
    39.     }
    41.     @Override
    42.     public void execute() {
    43.         lightReceiver.lightOn();
    44.     }
    46.     @Override
    47.     public void undo() {
    48.         lightReceiver.lightOff();
    49.     }
    50. }
    53. public class LightOffCommand implements Command {
    55.     /**
    56.      * 聚合LightReceiver
    57.      */
    58.     LightReceiver lightReceiver;
    60.     /**
    61.      * 构造器
    62.      * @param lightReceiver
    63.      */
    64.     public LightOffCommand(LightReceiver lightReceiver){
    65.         super();
    66.         this.lightReceiver = lightReceiver;
    67.     }
    69.     @Override
    70.     public void execute() {
    71.         lightReceiver.lightOff();
    72.     }
    74.     @Override
    75.     public void undo() {
    76.         lightReceiver.lightOn();
    77.     }
    78. }
    82. /**
    83.  * 空命令，没有任何执行，用来初始化每个按钮
    84.  * 调用空命令时，对象什么都不做
    85.  */
    86. public class NoCommand implements Command {
    87.     @Override
    88.     public void execute() {}
    90.     @Override
    91.     public void undo() {}
    92. }
    95. /**
    96.  * 遥控器
    97.  */
    98. public class RemoteController {
    100.     Command[] onCommands;
    101.     Command[] offCommands;
    103.     Command undoCommand;
    105.     public RemoteController(){
    106.         //以三组按钮为例
    107.         onCommands = new Command[3];
    108.         offCommands = new Command[3];
    109.         //按钮初始化
    110.         for (int i=0; i<3; i++){
    111.             onCommands[i] = new NoCommand();
    112.             offCommands[i] = new NoCommand();
    113.         }
    114.     }
    116.     public void setCommand(Integer no, Command onCommand, Command offCommand){
    117.         onCommands[no] = onCommand;
    118.         offCommands[no] = offCommand;
    119.     }
    121.     /**
    122.      * 按下开的按钮
    123.      * @param no
    124.      */
    125.     public void onButtonPushed(Integer no){
    126.         onCommands[no].execute();
    127.         undoCommand = onCommands[no];
    128.     }
    130.     /**
    131.      * 按下关的按钮
    132.      * @param no
    133.      */
    134.     public void ofButtonPushed(Integer no){
    135.         offCommands[no].execute();
    136.         undoCommand = offCommands[no];
    137.     }
    139.     /**
    140.      * 按下撤销按钮
    141.      */
    142.     public void undoButtonPushed(){
    143.         undoCommand.undo();
    144.     }
    145. }
    148. public class Client {
    149.     public static void main(String[] args) {
    150.         //创建电灯对象（接收者）
    151.         LightReceiver lightReceiver = new LightReceiver();
    152.         //创建电灯开关命令
    153.         LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
    154.         LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);
    155.         //创建遥控器
    156.         RemoteController remoteController = new RemoteController();
    157.         remoteController.setCommand(0,lightOnCommand,lightOffCommand);
    158.         System.out.println("-----按下开的按钮-----");
    159.         remoteController.onButtonPushed(0);
    160.         System.out.println("-----按下关的按钮-----");
    161.         remoteController.ofButtonPushed(0);
    162.         System.out.println("-----按下撤销的按钮-----");
    163.         remoteController.undoButtonPushed();
    164.     }
    165. }

    程序执行结果：

    1. -----按下开的按钮-----
    2. 开灯
    3. -----按下关的按钮-----
    4. 关灯
    5. -----按下撤销的按钮-----
    6. 开灯

    命令模式的注意事项和细节：
    1、将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的execute()方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说“请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用
    2、容易设计一个命令队列。只要把命令对象放到队列，就可以多线程的执行命令
    3、容易实现对请求的撤销和重做
    4、命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度
    5、空命令也是一种设计模式，它为我们省去了判空的操作。在上面的例子中，如果没有使用空命令，每按下一个按键都要判空，会给编码带来一定的麻烦
    6、命令模式经典的应用场景：界面的一个按钮是一条命令、模拟CMD、订单的恢复与撤销、触发-反馈机制