命令模式

在我们编程应用中或者生活之中。我们希望用一个统一的遥控器，这个遥控器可以对家电进行统一的off和on操作，但是这些遥控器却不需要知道这些家电自动化的细节。

命令模式可以将“动作的请求者”从“动作的执行者”对象中解耦。请求者为遥控器，执行者为家电。

做法是把请求封装成一个特定的对象（如电灯对象）。所以如果对每个按钮都存储一个命令对象，那么当按下按钮的时候，就可以请命令对象做相关的工作。遥控器并不需要知道工作内容是什么，只要有个命令对象能和正确的对象沟通，把事情做好就行了。这样便实现了请求者与执行者之间的解耦。

首先我们要编写统一的命令接口

public interface Command {
    public void execute();
}

然后创建一个电灯， 该电灯有关闭和打开的操作。

class Light{
    public void on(){
        System.out.println("打开电灯");
    }
    public void off(){
        System.out.println("关闭电灯");
    }
}

原始的操作是让命令的调用者持有该灯操作如下

public class SimpleRemoteControl {
       public void lightControl(String type){
           Light light=new Light();
           if(type.equals("off"))
               light.off();
           else light.on();
       }
}

这样会造成请求者与执行者之间的耦合。如果该电灯还有调节灯光强弱的功能的话，我们就要对该对象中的方法进行修改，这样违反了设计原则“对修改关闭，对扩展开发”。

命令模式将这种控制提出，封装成对象。

class LightOnCommand implements Command{
    Light light;
    @Override
    public void execute() {
        // TODO Auto-generated method stub
        light.on();
    }
    public LightOnCommand(Light light){
        this.light=light;
    }
}
class LightOffCommand implements Command{
    Light light;
    @Override
    public void execute() {
        // TODO Auto-generated method stub
        light.off();
    }
    public LightOffCommand(Light light){
        this.light=light;
    }
}

这样，请求者只需要知道调用该命令对某家电控制，但是不知道该控制的细节，实现了请求者与执行者之间的解耦。

public class SimpleRemoteControl {
      Command slot;
      public SimpleRemoteControl(){

      }
      public void setCommand(Command command){
          slot=command;
      }
      public void buttonWasPressed(){
          slot.execute();
      }
}

但是我们并不想一个操作对应一个遥控器，我们想用一个遥控器对所有家电进行统一的管理。这样我们可以在 SimpleRemoteControl类中的成员变量Command设置成数组，来进行统一的管理，代码如下：

public class SimpleRemoteControl {
      Command[] onCommands;//统一的开按钮命令
      Command[] offCommands;//统一的关按钮命令
      public SimpleRemoteControl(){
          onCommands=new Command[7];
          offCommands=new Command[7];
          for(int i=0;i<7;i++){
              onCommands[i]=new NoCommand();
              offCommands[i]=new NoCommand();
          }
      }
      public void setCommand(int slot,Command onCommand,Command offCommand){
          onCommands[slot]=onCommand;
          offCommands[slot]=offCommand;
      }
      public void buttonWasPressed(int slot){
          onCommands[slot].execute();
      }
      public void buttonWasOff(int slot){
          offCommands[slot].execute();
      }
}

其中NoCommand为一个实现Command接口的空类，这样做的目的是可以省去在按钮按下判断按钮是否为空的操作。

class NoCommand implements Command{
    @Override
    public void execute() {
        // TODO Auto-generated method stub
        System.out.println("该按钮无效");
    }
}

该模式还能扩展，提供撤销功能。 我们生活中比如电视遥控器，经常想回到上一个看的频道，这样我们需要撤销当前操作。在编程中，其实我们只需要记录上一个操作是什么即可。如果我们想撤销多个命令，就要将该记录上一个操作的变量定义为一个堆栈，用堆栈来存储每次新操作的命令，撤销只需要将该命令从堆栈中移除。当然Command接口也要新添加undo撤销方法，并让子类实现该方法。

public interface Command {
    public void execute();
    public void undo();//撤销命令
}
class NoCommand implements Command{
    @Override
    public void execute() {
        // TODO Auto-generated method stub
        System.out.println("该按钮无效");
    }
    @Override
    public void undo() {
        // TODO Auto-generated method stub
    }
}
class LightOnCommand implements Command{
    Light light;
    @Override
    public void execute() {
        // TODO Auto-generated method stub
        light.on();
    }
    public LightOnCommand(Light light){
        this.light=light;
    }
    @Override
    public void undo() {
        // TODO Auto-generated method stub
        light.off();
    }
}
class LightOffCommand implements Command{
    Light light;
    @Override
    public void execute() {
        // TODO Auto-generated method stub
        light.off();
    }
    public LightOffCommand(Light light){
        this.light=light;
    }
    @Override
    public void undo() {
        // TODO Auto-generated method stub
        light.on();
    }
}

public class SimpleRemoteControl {
      Command[] onCommands;
      Command[] offCommands;
      Stack<Command> stack;//撤销栈，来存储命令记录
      public SimpleRemoteControl(){
          onCommands=new Command[7];
          offCommands=new Command[7];
          for(int i=0;i<7;i++){
              onCommands[i]=new NoCommand();
              offCommands[i]=new NoCommand();
          }
          stack=new Stack<>();
      }
      public void setCommand(int slot,Command onCommand,Command offCommand){
          onCommands[slot]=onCommand;
          offCommands[slot]=offCommand;
      }
      public void buttonWasPressed(int slot){
          onCommands[slot].execute();
          stack.push(onCommands[slot]);
      }
      public void buttonWasOff(int slot){
          offCommands[slot].execute();
          stack.push(offCommands[slot]);
      }
    public void undoButton(){

          if(!stack.isEmpty())
          {
              System.out.print("撤销命令：");
              stack.peek().execute();
              System.out.print("执行：");
              stack.pop().undo();
          }
      }
}

main方法

 public static void main(String[] args) {
        // TODO Auto-generated method stub
        SimpleRemoteControl remoteControl=new SimpleRemoteControl();
        Light living=new Light();
        LightOnCommand lightOnCommand=new LightOnCommand(living);
        LightOffCommand lightOffCommand=new LightOffCommand(living);

        remoteControl.setCommand(0, lightOnCommand, lightOffCommand);
        remoteControl.buttonWasPressed(0);
        remoteControl.buttonWasOff(0);
        System.out.println("撤销命令1：");
        remoteControl.undoButton();
        System.out.println("撤销命令2：");
        remoteControl.undoButton();
    }

命令模式：将请求封装成对象，这可以让你使用不同的请求、队列或者日志请求来参数化其他对象。命令模式也可以支持撤销操作。

命令模式降低了系统的耦合度，同时可以很容易的让新的命令添加进去，不用对原对象进行修改。

但是命令模式可能会导致系统过多的命令类。因为每一个命令都要实现Command接口生成新的类。

使用场景为  

1.系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。

2.系统需要在不同的时间指定请求、将请求排队和执行请求。

3.系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。

4.系统需要将一组操作组合在一起，即支持宏命令。

以上是自己的浅见，不喜勿喷哈。有错误希望指正。