基本命令模式

概述

每个命令被看成是一个对象来处理，命令调用者是实际发起命令的一方，命令接收者是实际执行命令的一方。用户需要做的就是让命令发起者执行某命令，并且从命令执行者那里获取命令执行以后的结果就行，所以用户只和命令发起者和命令执行者之间存在联系。

优点

1. 解耦。就是那个命令发起者和执行者。
2. 添加命令方便。
3. 灵活，其实概括起来就这俩字。

缺点

1. 命令可以很多，那不同的命令就有不同的类呗，那系统中的类就多呗，系统就复杂呗。

类图

基本命令模式.png

实现

调用

package com.company;

public class Main {

    public static void main(String[] args) {
    // write your code here
        Receiver receiver = new Receiver();

        CommandInterface command0 = new Command0(receiver);
        CommandInterface command1 = new Command1(receiver);
        CommandInterface noCommand = new NoCommand(receiver);

        Invoker invoker = new Invoker();

        invoker.setCommandInterface(command0);
        invoker.execute(command0);

        invoker.setCommandInterface(command1);
        invoker.execute(command1);

        invoker.setCommandInterface(noCommand);
        invoker.execute(noCommand);
    }
}

执行

执行了命令0
执行了命令1
此处执行了空命令，就是啥都不做

Process finished with exit code 0

命令调用者

package com.company;

public class Invoker {
    /**
     * 一个抽象类型的私有成员
     */
    private CommandInterface commandInterface;

    /**
     * 供外界调用设置命令用的
     * @param commandInterface 一个命令
     */
    public void setCommandInterface(CommandInterface commandInterface) {
        this.commandInterface = commandInterface;
    }

    /**
     * 执行抽象命令的接口
     * @param command
     */
    public void execute(CommandInterface command) {
        commandInterface.execute();
    }
}

命令接收者

package com.company;

public class Receiver {
    public void action1() {
        System.out.println("执行了命令1");
    }

    public void action0() {
        System.out.println("执行了命令0");
    }
}

命令接口

package com.company;

public interface CommandInterface {
    /**
     * 执行命令的方法。
     */
    void execute();
}

命令0

package com.company;

public class Command0 implements CommandInterface {
    private Receiver receiver;

    public Command0(Receiver receiver) {
        this.receiver = receiver;
    }

    /**
     * 执行命令的方法。
     */
    @Override
    public void execute() {
        receiver.action0();
    }
}

命令1

package com.company;

public class Command1 implements CommandInterface {
    private Receiver receiver;

    public Command1(Receiver receiver) {
        this.receiver = receiver;
    }

    /**
     * 执行命令的方法。
     */
    @Override
    public void execute() {
        receiver.action1();
    }
}

无命令

package com.company;

public class NoCommand implements CommandInterface {
    private Receiver receiver;

    public NoCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    /**
     * 执行命令的方法。
     */
    @Override
    public void execute() {
        System.out.println("此处执行了空命令，就是啥都不做");
    }
}

Chapter 6 the Command Pattern (Encapsulating Invocation)