命令模式是一个高内聚的模式，其定义为：将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请 求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

UML：

 示例：多功能遥控器

public interface Command {

    void exec();

    void undo();
}

public class NullCommand implements Command {

    @Override
    public void exec() {
    }

    @Override
    public void undo() {
    }
}

//电灯遥控命令
public class LightCommand implements Command {

    private final LightReceiver lightReceiver;

    public LightCommand(LightReceiver lightReceiver) {
        this.lightReceiver = lightReceiver;
    }

    @Override
    public void exec() {
        lightReceiver.on();
    }

    @Override
    public void undo() {
        lightReceiver.off();
    }
}

public class LightReceiver {

    public void on() {
        System.out.println(" 打开电灯...");
    }

    public void off() {
        System.out.println(" 关闭电灯...");
    }
}

遥控器：

public class RemoteControl {
    private final Command[] commands;

    public RemoteControl() {
        this.commands = new Command[5];
        for (int i = 0; i < this.commands.length; i++) {
            this.commands[i] = new NullCommand();
        }
    }

    public void setCommend(int index, Command command) {
        this.commands[index] = command;
    }

    public void exec(int index) {
        this.commands[index].exec();
    }


    public void undo(int index) {
        this.commands[index].undo();
    }
}

client：

public class ClientDemo {

    public static void main(String[] args) {
        LightCommand lightCommand = new LightCommand(new LightReceiver());
        RemoteControl remoteControl = new RemoteControl();

        remoteControl.setCommend(0,lightCommand);

        remoteControl.exec(0);
        remoteControl.undo(0);

    }
}

 打开电灯...
 关闭电灯...

命令模式的主要优点如下。

1. 通过引入中间件（抽象接口）降低系统的耦合度。
2. 扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足“开闭原则”。
3. 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
4. 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
5. 可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活。

其缺点是：

1. 可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性。
2. 命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量，代码抽离肯定比代码聚合更加难理解。