定义：将一个请求封装成一个对象，从而让用户使用不同的请求把客户端参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。
使用场景：
1、需要抽象出待执行的动作，然后以参数的形式提供出来——类似与过程设计中的回调机制，而命令模式正式回调机制的一个面向对象的替代品。
2、在不同的时刻指定、排列和执行请求。一个命令对象可以有与初始请求无关的生存期。
3、需要支持取消操作。
4、支持修改日志的功能，这样当系统崩溃时，这些修改可以被重做一遍。
5、需要支持事务操作。

俄罗斯方块简单实现

/**
 * 接收者
 */
public class TetrisMachine {
    /**
     * 真正处理"向左"操作的逻辑代码
     */
    public void toLeft() {
        Log.e("向左");
    }

    public void toRight() {
        Log.e("向右");
    }

    public void fastToBottom() {
        Log.e("快速落下");
    }

    public void transform() {
        Log.e("改变形状");
    }

}

/**
 * 命令者 抽象
 */
public abstract class Command {
    protected TetrisMachine machine;

    public Command(TetrisMachine machine) {
        this.machine = machine;
    }

    /**
     * 命令执行方法
     */
   abstract void execute();
}

public class LeftCommand extends Command {
    public LeftCommand(TetrisMachine machine) {
        super(machine);
    }

    @Override
    public void execute() {
        machine.toLeft();
    }
}

public class RightCommand extends Command {
    public RightCommand(TetrisMachine machine) {
        super(machine);
    }

    @Override
    void execute() {
        machine.toRight();
    }
}

public class FallCommand extends Command {
    public FallCommand(TetrisMachine machine) {
        super(machine);
    }

    @Override
    void execute() {
        machine.fastToBottom();
    }
}

public class TransformCommand extends Command {
    public TransformCommand(TetrisMachine machine) {
        super(machine);
    }

    @Override
    void execute() {
        machine.transform();
    }
}

public class Buttons {
    private LeftCommand leftCommand;
    private RightCommand rightCommand;
    private FallCommand fallCommand;
    private TransformCommand transformCommand;

    public void setLeftCommand(LeftCommand leftCommand) {
        this.leftCommand = leftCommand;
    }

    public void setRightCommand(RightCommand rightCommand) {
        this.rightCommand = rightCommand;
    }

    public void setFallCommand(FallCommand fallCommand) {
        this.fallCommand = fallCommand;
    }

    public void setTransformCommand(TransformCommand transformCommand) {
        this.transformCommand = transformCommand;
    }

    public void toLeft() {
        leftCommand.execute();
    }

    public void toRight() {
        rightCommand.execute();
    }

    public void fall() {
        fallCommand.execute();
    }

    public void transform() {
        transformCommand.execute();
    }
}


public class Main {
    public static void main(String[] args){
        //接收者
        TetrisMachine machine=new TetrisMachine();
        //4种命令
        Buttons buttons=new Buttons();
        buttons.setLeftCommand(new LeftCommand(machine));
        buttons.setRightCommand(new RightCommand(machine));
        buttons.setFallCommand(new FallCommand(machine));
        buttons.setTransformCommand(new TransformCommand(machine));
        //具体按下哪个按钮玩家说了算
        buttons.toLeft();
        buttons.toRight();
        buttons.fall();
        buttons.transform();
    }
}

看上去好像还复杂化了，直接创建TetrisMachine对象，调用方法不就好了？？？
之所以有命令者和请求者，命令者是遵从开闭原则而请求者则是为了实现命令的记录、撤销等等操作。