命名、命令就是我下一个命令你就要来执行，我不关心谁来实现的，我只关心我的命令执没执行。命令模式就是将命令和执行封装在一起，并且高层组件是接触不到底层组件的，实现了调用者和执行者解耦合
看一下类图
命令模式类图
Command：定义了命令的抽象
ConcreteCommand：是具体的命令实现类，他实现了具体的execute()
Invoker：是接口人他用来接收命令和执行命令
Receiver：真正执行命令的
这里假设一个场景，是一个软件项目建立，有用户，产品经理，程序员，设计，还有一个项目经理。如果说没有项目经理，那用户要改功能，需求和页面都需要去找相应的人员，有的时候你找的还不一定是对的人。如果你是用户你会不会觉得很麻烦，我直接找项目经理告诉你我要做什么你给我找人去做就完了。
用户就是高层调用发送具体命令ConcreteCommand
产品经理，程序员，设计就是Receiver
项目经理是Invoker
1，定义执行角色的抽象类
public abstract class Group {
//甲乙双方办公，如果你要和某个组讨论，首先要找到这个组
public abstract void find();
//被要求增加功能
public abstract void add();
//被要求删除功能
public abstract void delete();
//被要求修改功能
public abstract void change();
//被要求给出所有变更计划
public abstract void plan();
}
2，定义各个角色的具体实现
public class PageGroup extends Group{
@Override
public void find() {
System.out.println("找到美工组。。。");
}
@Override
public void add() {
System.out.println("客户要求增加一条页面。。。");
}
@Override
public void delete() {
System.out.println("客户要求删除一条页面。。。");
}
@Override
public void change() {
System.out.println("客户要求修改一条页面。。。");
}
@Override
public void plan() {
System.out.println("客户要求变更一条页面。。。");
}
}
public class RequirementGroup extends Group{
@Override
public void find() {
System.out.println("找到需求组。。。");
}
@Override
public void add() {
System.out.println("客户要求增加一条需求。。。");
}
@Override
public void delete() {
System.out.println("客户要求删除一条需求。。。");
}
@Override
public void change() {
System.out.println("客户要求修改一条需求。。。");
}
@Override
public void plan() {
System.out.println("客户要求变更一条需求。。。");
}
}
public class CodeGroup extends Group{
@Override
public void find() {
System.out.println("找到代码组。。。");
}
@Override
public void add() {
System.out.println("客户要求增加一条功能。。。");
}
@Override
public void delete() {
System.out.println("客户要求删除一条功能。。。");
}
@Override
public void change() {
System.out.println("客户要求修改一条功能。。。");
}
@Override
public void plan() {
System.out.println("客户要求变更一条功能。。。");
}
}
3，定义抽象的命令
public abstract class Command {
//把三组都定义好子类可以直接使用
protected RequirementGroup rg = new RequirementGroup();
protected PageGroup pg = new PageGroup();
protected CodeGroup cg = new CodeGroup();
//只有一个方法你要我做什么事
public abstract void execute();
}
4，定义具体的命令，增加一个需求，减少一个页面
public class AddRequirementCommand extends Command{
@Override
public void execute() {
super.rg.find();
super.rg.add();
super.rg.plan();
}
}
public class DeletePageCommand extends Command{
@Override
public void execute() {
pg.find();
pg.delete();
pg.plan();
}
}
5，定义一接口人
//接口人
public class Invoker {
private Command command;
//客户发出命令
public void setCommand(Command command){
this.command = command;
}
//执行客户命令
public void action(){
this.command.execute();
}
}
6，调用
public class Main {
public static void main(String[] args){
//定义接头人
Invoker invoker = new Invoker();
System.out.println("--------------客户要求增加一项需求---------------");
Command command = new AddRequirementCommand();
invoker.setCommand(command);
invoker.action();
}
}
总结：我们看到在高层组件调用时只需要让接头人去执行一个命令就行了，调用者根本就不知道是谁实现的，也就是调用和实现分离，实现了高内聚，如果我们要修改对应命令的实现直接修改命令中的调用execute即可
使用时要注意因为每一个命令都要建立一个命令类，所以可能会导致类爆炸
命令模式也可以实现请求排队和命令撤销恢复的功能
