命令模式（command pattern）

简述：为了让命令的请求者与命令的执行方解耦，说白了就是加入一个中间商，让请求者不用关心具体的命令执行细节。然后还可以对命令进行排队，记录日志，撤销等附加控制功能。其实就是为了让具体的执行不放在客户端中，从而减少耦合（就是扩展性好，不用一改需求就修改大量的代码）

结构图：

示例：模拟饭店的点餐、做菜场景，角色有厨师、服务员、顾客。厨师就是命令的执行者（接收者）、服务员就是命令的发起者、顾客就是客户端命令的请求者

1.0：这个版本只有顾客和厨师，顾客直接命令厨师进行做菜

package commandpattern.version1;

public class Client {

    public static void main(String[] args) {
        Chicken chicken = new Chicken();
        chicken.makemapodoufu();
        chicken.makexianglayousi();
        chicken.makexianglayousi();
        chicken.unmakemapodoufu();
        chicken.unmakemapodoufu();
        chicken.makexianglayousi();
        /**
         * 做一份麻婆豆腐
         * 做一份香辣肉丝
         * 做一份香辣肉丝
         * 麻婆豆腐不做了
         * 麻婆豆腐不做了
         * 做一份香辣肉丝
         */
    }

}


class Chicken {
    public void makexianglayousi() {
        System.out.println("做一份香辣肉丝");
    }
    public void unmakexianglayousi() {
        System.out.println("香辣肉丝不做了");
    }

    public void makemapodoufu() {
        System.out.println("做一份麻婆豆腐");
    }
    public void unmakemapodoufu() {
        System.out.println("麻婆豆腐不做了");
    }
}

第一个版本，简单看下其实没什么问题，不过有个小问题就是顾客其实只要了一份麻婆豆腐，结果要求不要了两份，不合理吧，当然这个问题可以让厨师来控制，将每个顾客的菜都记录好，然后不做的时候去判断下，然后还有最后的算账都可以厨师来计算 没有任何问题，不过我们想想，如果加了一种菜，怎么办，厨师类就要做大量的更改，最起码需要加一个做菜和不做了的方法，然后可能还需要处理算账和每个顾客的独特需求

缺点：

1. 请求者和执行者，直接接触，耦合度高

2. 违背了开闭原则，在增加和减少命令需要修改相应类

2.0：

package commandpattern.version2;

public class Client {

    public static void main(String[] args) {
        Chicken chicken = new Chicken();
        Command xianglarousiCommand = new XianglarousiCommand(chicken);
        Command mapodoufuCommand = new MapodoufuCommand(chicken);

        Waiter waiter = new Waiter();
        waiter.SetOrder(xianglarousiCommand);
        waiter.Notify();
        waiter.SetOrder(mapodoufuCommand);
        waiter.Notify();
        /**
         * 做一份香辣肉丝
         * 做一份麻婆豆腐
         */
    }

}

//厨师的工作就是做菜或者撤销菜  不需要做其他工作
class Chicken {
    public void makexianglayousi() {
        System.out.println("做一份香辣肉丝");
    }
    public void makemapodoufu() {
        System.out.println("做一份麻婆豆腐");
    }
}
//服务员的工作就是命令厨师做什么菜撤销什么菜
class Waiter {
    private Command command;

    public void SetOrder(Command command) {
        this.command = command;
    }

    public void Notify() {
        command.ExcuteCommand();
    }
}

abstract class Command {
    protected Chicken receiver;

    public Command(Chicken receiver) {
        this.receiver = receiver;
    }

    abstract public void ExcuteCommand();
}

class XianglarousiCommand extends Command{

    public XianglarousiCommand(Chicken receiver) {
        super(receiver);
    }

    @Override
    public void ExcuteCommand() {
        receiver.makexianglayousi();
    }
}

class MapodoufuCommand extends Command{

    public MapodoufuCommand(Chicken receiver) {
        super(receiver);
    }

    @Override
    public void ExcuteCommand() {
        receiver.makemapodoufu();
    }
}

第二版 将请求者和执行者分开，耦合度降低，那么怎么降低的呢，举个例子，如果按照第二版我们想加一个，鱼香肉丝，只需要在chicken中加一个函数 然后加入相应的命令类，客户端就可以调用了，要比第一版改动小的多，而且在第二版中各种命令控制都可以在waiter中进行控制，当然这不是主要任务。第二版最主要的就是解耦