命令模式

1.命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

2.命令模式分为5个角色，抽象命令，具体命令，请求者，执行者，客户端。常见的键盘操作就是这种模式，键盘是请求者，持有具体的命令，游戏等软件是执行者，操作的人就是客户端。

3.命令模式的优点：
●　　更松散的耦合
命令模式使得发起命令的对象——客户端，和具体实现命令的对象——接收者对象完全解耦，也就是说发起命令的对象完全不知道具体实现对象是谁，也不知道如何实现。

●　　更动态的控制
　　命令模式把请求封装起来，可以动态地对它进行参数化、队列化和日志化等操作，从而使得系统更灵活。

●　　很自然的复合命令
　　命令模式中的命令对象能够很容易地组合成复合命令，也就是宏命令，从而使系统操作更简单，功能更强大。

●　　更好的扩展性
　　由于发起命令的对象和具体的实现完全解耦，因此扩展新的命令就很容易，只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象中，然后就可以使用这个命令对象，已有的实现完全不用变化。

示例如下：

public class Command {
    public static void main(String[] args){
        Command command=new Command();
        Game game=command.new Game();
        IGameCommand left=command.new GameLeftCommand(game);
        IGameCommand right=command.new GameRightCommand(game);
        IGameCommand jump=command.new GameJumpCommand(game);
        Invoke invoke = command.new Invoke();
        Scanner scanner=new Scanner(System.in);
        Random random=new Random();
        System.out.println("请输入命令：");
        while (scanner.hasNext()){
            String next= scanner.next();
            switch (next){
                case "1":
                    invoke.setiGameCommand(left);
                    invoke.execute(random.nextInt(10));
                    break;
                case "2":
                    invoke.setiGameCommand(right);
                    invoke.execute(random.nextInt(10));
                    break;
                case "3":
                    invoke.setiGameCommand(jump);
                    invoke.execute(0);
                    break;
                case "0":
                    System.out.println("退出");
                    System.exit(0);
                    break;
                default:
                    System.out.println("未知命令");
                    break;
            }
        }
    }

    class Game{
        public void goLeft(int step){
            System.out.println("向左走"+ step+"步");
        }
        public void goRight(int step){
            System.out.println("向右走"+ step+"步");
        }
        public void jump(int step){
            System.out.println("跳起来");
        }
    }

    interface IGameCommand{
        void execute(int step);
    }

    class GameCommand{
        protected Game game;
        public GameCommand(Game game) {
            this.game = game;
        }
    }

    class GameLeftCommand extends GameCommand implements IGameCommand{
        public GameLeftCommand(Game game) {
            super(game);
        }

        @Override
        public void execute(int step) {
            game.goLeft(step);
        }
    }

    class GameRightCommand extends GameCommand implements IGameCommand{
        public GameRightCommand(Game game) {
            super(game);
        }

        @Override
        public void execute(int step) {
            game.goRight(step);
        }
    }

    class GameJumpCommand extends GameCommand implements IGameCommand{
        public GameJumpCommand(Game game) {
            super(game);
        }

        @Override
        public void execute(int step) {
            game.jump(step);
        }
    }

    class Invoke{
        private IGameCommand iGameCommand;

        public void setiGameCommand(IGameCommand iGameCommand) {
            this.iGameCommand = iGameCommand;
        }

        public void execute(int step){
            iGameCommand.execute(step);
        }
    }

}