命令模式（设计模式详解版）-亚博电竞手机版

命令模式的定义与特点

1. 通过引入中间件（抽象接口）降低系统的耦合度。
2. 扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足“开闭原则”。
3. 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
4. 方便实现 undo 和 redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。
5. 可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活。

1. 可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性。
2. 命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量，代码抽离肯定比代码聚合更加难理解。

命令模式的结构与实现

1. 模式的结构

1. 抽象命令类（command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
2. 具体命令类（concrete command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
3. 实现者/接收者（receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
4. 调用者/请求者（invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

2. 模式的实现

 package command;  public class commandpattern {     public static void main(string[] args) {         command cmd = new concretecommand();         invoker ir = new invoker(cmd);         system.out.println("客户访问调用者的call()方法...");         ir.call();     } }  //调用者 class invoker {     private command command;      public invoker(command command) {         this.command = command;     }      public void setcommand(command command) {         this.command = command;     }      public void call() {         system.out.println("调用者执行命令command...");         command.execute();     } }  //抽象命令 interface command {     public abstract void execute(); }  //具体命令 class concretecommand implements command {     private receiver receiver;      concretecommand() {         receiver = new receiver();     }      public void execute() {         receiver.action();     } }  //接收者 class receiver {     public void action() {         system.out.println("接收者的action()方法被调用...");     } }

 客户访问调用者的call()方法... 调用者执行命令command... 接收者的action()方法被调用...

命令模式的应用实例

• 首先，定义一个早餐类（breakfast），它是抽象命令类，有抽象方法 cooking()，说明要做什么；
• 再定义其子类肠粉类（changfen）、馄饨类（huntun）和河粉类（hefen），它们是具体命令类，实现早餐类的 cooking() 方法，但它们不会具体做，而是交给具体的厨师去做；
• 具体厨师类有肠粉厨师（changfenchef）、馄饨厨师（huntunchef）和河粉厨师（hefenchef），他们是命令的接收者。

 package command;  import javax.swing.*;  public class cookingcommand {     public static void main(string[] args) {         breakfast food1 = new changfen();         breakfast food2 = new huntun();         breakfast food3 = new hefen();         waiter fwy = new waiter();         fwy.setchangfen(food1);//设置肠粉菜单         fwy.sethuntun(food2);  //设置河粉菜单         fwy.sethefen(food3);   //设置馄饨菜单         fwy.choosechangfen();  //选择肠粉         fwy.choosehefen();     //选择河粉         fwy.choosehuntun();    //选择馄饨     } }  //调用者：服务员 class waiter {     private breakfast changfen, huntun, hefen;      public void setchangfen(breakfast f) {         changfen = f;     }      public void sethuntun(breakfast f) {         huntun = f;     }      public void sethefen(breakfast f) {         hefen = f;     }      public void choosechangfen() {         changfen.cooking();     }      public void choosehuntun() {         huntun.cooking();     }      public void choosehefen() {         hefen.cooking();     } }  //抽象命令：早餐 interface breakfast {     public abstract void cooking(); }  //具体命令：肠粉 class changfen implements breakfast {     private changfenchef receiver;      changfen() {         receiver = new changfenchef();     }      public void cooking() {         receiver.cooking();     } }  //具体命令：馄饨 class huntun implements breakfast {     private huntunchef receiver;      huntun() {         receiver = new huntunchef();     }      public void cooking() {         receiver.cooking();     } }  //具体命令：河粉 class hefen implements breakfast {     private hefenchef receiver;      hefen() {         receiver = new hefenchef();     }      public void cooking() {         receiver.cooking();     } }  //接收者：肠粉厨师 class changfenchef extends jframe {     private static final long serialversionuid = 1l;     jlabel l = new jlabel();      changfenchef() {         super("煮肠粉");         l.seticon(new imageicon("src/command/changfen.jpg"));         this.add(l);         this.setlocation(30, 30);         this.pack();         this.setresizable(false);         this.setdefaultcloseoperation(jframe.exit_on_close);     }      public void cooking() {         this.setvisible(true);     } }  //接收者：馄饨厨师 class huntunchef extends jframe {     private static final long serialversionuid = 1l;     jlabel l = new jlabel();      huntunchef() {         super("煮馄饨");         l.seticon(new imageicon("src/command/huntun.jpg"));         this.add(l);         this.setlocation(350, 50);         this.pack();         this.setresizable(false);         this.setdefaultcloseoperation(jframe.exit_on_close);     }      public void cooking() {         this.setvisible(true);     } }  //接收者：河粉厨师 class hefenchef extends jframe {     private static final long serialversionuid = 1l;     jlabel l = new jlabel();      hefenchef() {         super("煮河粉");         l.seticon(new imageicon("src/command/hefen.jpg"));         this.add(l);         this.setlocation(200, 280);         this.pack();         this.setresizable(false);         this.setdefaultcloseoperation(jframe.exit_on_close);     }      public void cooking() {         this.setvisible(true);     } }

命令模式的应用场景

1. 请求调用者需要与请求接收者解耦时，命令模式可以使调用者和接收者不直接交互。
2. 系统随机请求命令或经常增加、删除命令时，命令模式可以方便地实现这些功能。
3. 当系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能。
4. 当系统需要支持命令的撤销（undo）操作和恢复（redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现。

命令模式的扩展

 package command;  import java.util.arraylist;  public class compositecommandpattern {     public static void main(string[] args) {         abstractcommand cmd1 = new concretecommand1();         abstractcommand cmd2 = new concretecommand2();         compositeinvoker ir = new compositeinvoker();         ir.add(cmd1);         ir.add(cmd2);         system.out.println("客户访问调用者的execute()方法...");         ir.execute();     } }  //抽象命令 interface abstractcommand {     public abstract void execute(); }  //树叶构件: 具体命令1 class concretecommand1 implements abstractcommand {     private compositereceiver receiver;      concretecommand1() {         receiver = new compositereceiver();     }      public void execute() {         receiver.action1();     } }  //树叶构件: 具体命令2 class concretecommand2 implements abstractcommand {     private compositereceiver receiver;      concretecommand2() {         receiver = new compositereceiver();     }      public void execute() {         receiver.action2();     } }  //树枝构件: 调用者 class compositeinvoker implements abstractcommand {     private arraylist children = new arraylist();      public void add(abstractcommand c) {         children.add(c);     }      public void remove(abstractcommand c) {         children.remove(c);     }      public abstractcommand getchild(int i) {         return children.get(i);     }      public void execute() {         for (object obj : children) {             ((abstractcommand) obj).execute();         }     } }  //接收者 class compositereceiver {     public void action1() {         system.out.println("接收者的action1()方法被调用...");     }      public void action2() {         system.out.println("接收者的action2()方法被调用...");     } }

 客户访问调用者的execute()方法... 接收者的action1()方法被调用... 接收者的action2()方法被调用...