1.策略模式

  • 策略模式(Strategy Pattern)
    • 定义⼀系列的算法,把它们⼀个个封装起来, 并且使它们 可相互替换
    • 淘宝天猫双⼗⼀，正在搞活动有打折的、有满减的、有返利的等等，这些算法只是⼀种策略，并且是随时都可能互相替换的, 我们就可以定义⼀组算法，将每个算法

都封装起来，并且使它们之间可以互换

  • 应⽤场景

    • ⽼王计划外出旅游，选择骑⾃⾏⻋、坐汽⻋、⻜机等， 每⼀种旅⾏⽅式都是⼀个策略
    • Java AWT中的LayoutManager，即布局管理器
    • 如果在⼀个系统⾥⾯有许多类，它们之间的区别仅在于它们的⾏为，那么可以使⽤策略模式
    • 不希望暴露复杂的、与算法有关的数据结构，那么可以 使⽤策略模式来封装算法

  • ⻆⾊

    • Context上下⽂：屏蔽⾼层模块对策略、算法的直接访问，封装可能存在的变化
    • Strategy策略⻆⾊：抽象策略⻆⾊，是对策略、算法家族的抽象，定义每个策略或算法必须具有的⽅法和属性
    • ConcreteStrategy具体策略⻆⾊：⽤于实现抽象策略中的操作，即实现具体的算法

image.png

  • 业务需求

    ⽼王⾯试进了⼤⼚，是电商项⽬的营销活动组，负责多个营销活 动，有折扣、优惠券抵扣、满减等，项⽬上线后，产品经理找茬，经常新增营销活动，导致代码改动多，加班严重搞的⽼王很 恼⽕。 他发现这些都是活动策略，商品的价格是根据不同的活动策略进 ⾏计算的，因此⽤策略设计模式进⾏了优化，后续新增策略后只 要简单配置就⾏了，不⽤⼤动⼲⼽

  1. public abstract class Strategy {
  3.     /**
  4.      *  根据简单订单对象，计算商品折扣后的价格
  5.      * @param productOrder
  6.      * @return
  7.      */
  8.     public abstract double computePrice(ProductOrder productOrder);
  10. }
  1. public class PromotionContext {
  3.     private Strategy strategy;
  5.     public  PromotionContext(Strategy strategy){
  6.         this.strategy = strategy;
  7.     }
  10.     /**
  11.      * 根据策略计算最终的价格
  12.      * @param productOrder
  13.      * @return
  14.      */
  15.     public double executeStrategy(ProductOrder productOrder){
  16.         return strategy.computePrice(productOrder);
  17.     }
  19. }
  1. public class DiscountActivity extends  Strategy{
  3.     /**
  4.      * 具体的折扣
  5.      */
  6.     private double rate;
  8.     public DiscountActivity(double rate){
  9.         this.rate = rate;
  10.     }
  12.     @Override
  13.     public double computePrice(ProductOrder productOrder) {
  14.         //一系列复杂的计算
  16.         return  productOrder.getOldPrice() * rate;
  18.     }
  19. }
  1. public class NormalActivity extends Strategy{
  3.     @Override
  4.     public double computePrice(ProductOrder productOrder) {
  6.         return productOrder.getOldPrice();
  7.     }
  8. }
  2. public class VoucherActivity extends Strategy {
  4.     /**
  5.      * 传入优惠券
  6.      */
  7.     private double voucher;
  10.     public  VoucherActivity(double voucher){
  11.         this.voucher = voucher;
  12.     }
  15.     @Override
  16.     public double computePrice(ProductOrder productOrder) {
  18.         if(productOrder.getOldPrice() > voucher){
  19.             return productOrder.getOldPrice() - voucher;
  20.         }else {
  21.             return 0;
  22.         }
  24.     }
  25. }
  1. public class ProductOrder {
  3.     private double oldPrice;
  5.     private int userId;
  7.     private int productId;
  10.     public ProductOrder(double oldPrice, int userId, int productId){
  11.         this.oldPrice = oldPrice;
  13.         this.userId = userId;
  15.         this.productId = productId;
  16.     }
  18.     //getter/setter
  19. }

  • 优点

    • 满⾜开闭原则，当增加新的具体策略时，不需要修改上下⽂类的代码，上下⽂就可以引⽤新的具体策略的实例
    • 避免使⽤多重条件判断，如果不⽤策略模式可能会使⽤ 多重条件语句不利于维护，和⼯⼚模式的搭配使⽤可以 很好地消除代码if-else的多层嵌套（⼯⼚模式主要是根 据参数，获取不同的策略）

  • 缺点

    • 策略类数量会增多，每个策略都是⼀个类，复⽤的可能 性很⼩
    • 对外暴露了类所有的⾏为和算法，⾏为过多导致策略类 膨胀

  • JDK源码的应⽤

    • Comparator 接⼝常⽤的 compare()⽅法，就是⼀个策略设计模式的应⽤，把 Comparator 作为参数使⽤⽣成不同的排序策略
      1. List<Student> list = new ArrayList<>(); 
      2. list.add(new Student("Anna", 15)); 
      3. list.add(new Student("⼩D", 18)); 
      4. list.add(new Student("⽼王", 20)); 
      5. // 对伙伴的集合按年龄进⾏排序 
      6. Collections.sort(list, new Comparator<Student>() { 
      7. @Override 
      8. public int compare(Student s1, Student s2) { 
      9.     // 升序 
      10.     //return s1.getAge()-s2.getAge(); 
      11.     // 降序 
      12.     // return s2.getAge()-s1.getAge(); 
      13. } 
      14. });

2.模板方法模式

  • 模板⽅法模式Template Method

    • 定义⼀个操作中的算法⻣架，将算法的⼀些步骤延迟到⼦类中，使得⼦类可以不改变该算法结构的情况下重定义该算法的某些特定步骤，属于⾏为型模式

  • 应⽤场景

    • javaweb⾥⾯的Servlet，HttpService类提供了⼀个 service( )⽅法
    • 有多个⼦类共有逻辑相同的⽅法，可以考虑作为模板⽅法
    • 设计⼀个系统时知道了算法所需的关键步骤，且确定了这些步骤的执⾏顺序，但某些步骤的具体实现还未知， 可以延迟到⼦类进⾏完成
  1. /**
  2. * 抽象类(Abstract Class)
  3. */
  4. public abstract class AbstractClass {
  6.     /**
  7.     *  模版⽅法
  8.     */
  9.     public void templateMethod() {
  10.         specificMethod();
  11.         abstractMethod1();
  12.         abstractMethod2();
  13.     }
  15.     /**
  16.     *具体⽅法
  17.     */
  18.     public void specificMethod() {
  19.             System.out.println("抽象类中的具体⽅法被调⽤");
  20.     }
  22.     // 抽象⽅法1
  23.     public abstract void abstractMethod1();
  24.     // 抽象⽅法2
  25.     public abstract void abstractMethod2();
  26. }
  • ⻆⾊
    • 抽象模板(Abstract Template):

定义⼀个模板⽅法，这 个模板⽅法⼀般是⼀个具体⽅法，给出⼀个顶级算法⻣ 架，⽽逻辑⻣架的组成步骤在相应的抽象操作中，推迟到⼦类实现 

  1.   - 模板⽅法：定义了算法的⻣架，按某种顺序调⽤其包含的基本⽅法 
  2.   - 基本⽅法：是整个算法中的⼀个步骤
  3.      - 抽象⽅法：在抽象类中申明，由具体⼦类实现。 
  4.      - 具体⽅法：在抽象类中已经实现，在具体⼦类中可以继承或重写它
  • 具体模板(Concrete Template):实现⽗类所定义的⼀个 或多个抽象⽅法，它们是⼀个顶级算法逻辑的组成步骤

image.png

⼩滴课堂-⽼王成功晋升为管理者，但是团队来了很多新兵，由于团队⽔平参差不⻬，经常有新项⽬进来，但整体流程很不规范。

⼀个项⽬的⽣命周期：需求评审-设计-开发-测试-上线-运维。整个周期⾥⾯，需求评审-设计是固定的操作，⽽其他步骤 则流程耗时等是根据项⽬来定的。

因此⽼王梳理了⼀个模板，来规范化项⽬，他只管核⼼步骤和项⽬⾥程碑产出的结果，具体的⼯时安排和开发就让团队成员去操作

编码实战 

  1. public abstract  class AbstractProjectManager {
  2.     /**
  3.      * 定义模板方法，声明final，防止子类覆盖他，更改顺序，流程是一样复用
  4.      */
  6.     public final void processProject(){
  8.         review();
  10.         degisn();
  12.         coding();
  14.         test();
  16.         online();
  18.     }
  21.     /**
  22.      * 各个项目都需要评审,具体方法
  23.      */
  24.     public void review(){
  25.         System.out.println("项目需求评审");
  26.     }
  29.     /**
  30.      * 各个项目都需要设计，具体方法
  31.      */
  32.     public void degisn(){
  33.         System.out.println("UI UE进行设计");
  34.     }
  36.     /**
  37.      * 抽象方法，由就具体子类进行实现，编码耗时不一样
  38.      */
  39.     public abstract void coding();
  43.     /**
  44.      * 抽象方法，由就具体子类进行实现，测试有多种，自动化测试、安全测试、压力测试、手工测试
  45.      */
  46.     public abstract void test();
  49.     /**
  50.      * 抽象方法，由就具体子类进行实现，上线有全量发布，灰度发布，停机发布
  51.      */
  52.     public abstract void online();
  53. }
  1. public class PayServiceProjectManager extends AbstractProjectManager {
  2.     @Override
  3.     public void coding() {
  4.         System.out.println("开发耗时30天");
  5.     }
  7.     @Override
  8.     public void test() {
  10.         System.out.println("功能测试，安全测试，压力测试");
  11.     }
  13.     @Override
  14.     public void online() {
  16.         System.out.println("全量上线");
  17.     }
  18. }
  2. public class UserServiceProjectManager extends AbstractProjectManager {
  3.     @Override
  4.     public void coding() {
  5.         System.out.println("开发耗时10天");
  6.     }
  8.     @Override
  9.     public void test() {
  11.         System.out.println("功能测试，压力测试,还有手工测试");
  12.     }
  14.     @Override
  15.     public void online() {
  17.         System.out.println("灰度发布，全量上线");
  18.     }
  19. }

  • 优点

    • 扩展性好，对不变的代码进⾏封装，对可变的进⾏扩展，符合 开闭原则

  • 提⾼代码复⽤性 将相同部分的代码放在抽象的⽗类中，将不同的代码放⼊不同的⼦类中

    • 通过⼀个⽗类调⽤其⼦类的操作，通过对⼦类的具体实 现扩展不同的⾏为，实现了反向控制

  • 缺点

    • 每⼀个不同的实现都需要⼀个⼦类来实现，导致类的个 数增加，会使系统变得复杂

  • 模板⽅法模式和建造者模式区别

    • 两者很⼤的交集，建造者模式⽐模板⽅法模式多了⼀个指挥类，该类体现的是模板⽅法模式中抽象类的固定算法的功能，是⼀个创建对象的固定算法

3.观察者设计模式

  • 观察者模式

    • 定义对象间⼀种⼀对多的依赖关系，使得每当⼀个对象改变状态，则所有依赖于它的对象都会得到通知并⾃动更新，也叫做发布订阅模式Publish/Subscribe，属于⾏为型模式

  • 应⽤场景

    • 消息通知⾥⾯：邮件通知、⼴播通知、微信朋友圈、微博私信等，就是监听观察事件
    • 当⼀个对象的改变需要同时改变其它对象，且它不知道 具体有多少对象有待改变的时候，考虑使⽤观察者模式

  • ⻆⾊

    • Subject主题：持有多个观察者对象的引⽤，抽象主题提供了⼀个接⼝可以增加和删除观察者对象；有⼀个观 察者数组，并实现增、删及通知操作
    • Observer抽象观察者：为具体观察者定义⼀个接⼝， 在得到主题的通知时更新⾃⼰
    • ConcreteSubject具体主题：将有关状态存⼊具体观察者对象，在具体主题内部状态改变时，给所有登记过的观察者发出通知
    • ConcreteObserver具体观察者：实现抽象观察者⻆⾊所要求的更新接⼝，以便使本身的状态与主题的状态保持⼀致

  • 优点

    • 降低了⽬标与观察者之间的耦合关系，⽬标与观察者之间建⽴了⼀套触发机制
    • 观察者和被观察者是抽象耦合的

  • 缺点

    • 观察者和观察⽬标之间有循环依赖的话，会触发它们之间进⾏循环调⽤，可能导致系统崩溃
    • ⼀个被观察者对象有很多的直接和间接的观察者的话， 将所有的观察者都通知到会花费很多时间

image.png

  1. public class Subject {
  3.     private List<Observer> observerList = new ArrayList<>();
  5.     /**
  6.      * 新增观察者
  7.      * @param observer
  8.      */
  9.     public void addObserver(Observer observer){
  10.         this.observerList.add(observer);
  11.     }
  14.     /**
  15.      *删除观察者
  16.      * @param observer
  17.      */
  18.     public void deleteObserver(Observer observer){
  19.         this.observerList.remove(observer);
  20.     }
  23.     public void notifyAllObserver(){
  24.         for(Observer observer:this.observerList){
  25.             observer.update();
  26.         }
  27.     }
  28. }
  1. public interface Observer {
  3.     /**
  4.      * 观察到消息后进行的操作，就是响应
  5.      */
  6.     void update();
  7. }
  2. public class BossConcreteSubject extends Subject {
  4.     public void doSomething(){
  5.         System.out.println("老板完成自己的工作");
  7.         //还有其他操作
  8.         System.out.println("视察公司工作情况");
  9.         super.notifyAllObserver();
  11.     }
  12. }
  2. public class AnnaConcreteObserver implements Observer {
  4.     @Override
  5.     public void update() {
  6.         System.out.println("Anna小姐姐发现领导到来，暂停在线摸鱼，回归工作");
  7.     }
  8. }
  1. public class LWConcreteObserver implements Observer {
  3.     @Override
  4.     public void update() {
  5.         System.out.println("老王发现领导到来，暂停在线摸鱼，回归工作");
  6.     }
  7. }

4.责任链设计模式

  • 责任链设计模式(Chain of Responsibility Pattern)

    • 客户端发出⼀个请求，链上的对象都有机会来处理这⼀请求，⽽客户端不需要知道谁是具体的处理对象
    • 让多个对象都有机会处理请求，避免请求的发送者和接收者之间的耦合关系，将这个对象连成⼀条调⽤链，并沿着这条链传递该请求，直到有⼀个对象处理它才终⽌
    • 有两个核⼼⾏为：⼀是处理请求，⼆是将请求传递到下⼀节点

  • 应⽤场景

    • Apache Tomcat 对 Encoding 编码处理的处理， SpringBoot⾥⾯的拦截器、过滤器链
    • 在请求处理者不明确的情况下向多个对象中的⼀个提交请求
    • 如果有多个对象可以处理同⼀个请求，但是具体由哪个对象处理是由运⾏时刻动态决定的，这种对象就可以使⽤职责链模式

  • ⻆⾊

    • Handler抽象处理者：定义了⼀个处理请求的接⼝
    • ConcreteHandler具体处理者： 处理所负责的请求，可 访问它的后续节点，如果可处理该请求就处理，否则就 将该请求转发给它的后续节点

image.png

  • 责任链设计模式案例实战
  • 业务需求

    ⻛控规则，就是对于每个场景，定义⼀些规则，来进⾏相应的控制，⽐如银⾏借款、⽀付宝提现、⼤额转账等 会触发不同的策 略。

    像互联⽹⾦融⾏业的话，除了公司内部政策，所处的外部环境经常发⽣变化，⽐如国家经常会出政策，这些都经常需要调整相应 的⻛控参数和⻛控级别。

    例⼦：⽀付宝转账，根据转账额度不同，会触发的⻛控级别不⼀ 样，1000元以下直接转，1千到1万需要⼿机号验证码，1万到以 上需要刷脸验证。

image.png

  1. public class Request {
  2.     /**
  3.      * 类别
  4.      */
  5.     private String requestType;
  7.     /**
  8.      * 金额
  9.      */
  10.     private int money;
  12.       //getter setter
  14. }
  17. public enum RequestType {
  19.     /**
  20.      * 转账
  21.      */
  22.     TRANSFER,
  24.     /**
  25.      * 提现
  26.      */
  27.     CASH_OUT;
  28. }
  2. public abstract class RiskControlManager {
  4.     protected  String name;
  6.     /**
  7.      * 更严格的风控策略
  8.      */
  9.     protected RiskControlManager superior;
  11.     public RiskControlManager(String name){
  12.         this.name = name;
  13.     }
  16.     /**
  17.      * 设置更严格的风控策略
  18.      * @param superior
  19.      */
  20.     public void setSuperior(RiskControlManager superior){
  21.         this.superior = superior;
  22.     }
  25.     /**
  26.      * 处理请求
  27.      * @param request
  28.      */
  29.     public abstract void handlerRequest(Request request);
  31. }
  1. public class FirstRiskControlManager extends RiskControlManager {
  3.     public FirstRiskControlManager(String name) {
  4.         super(name);
  5.     }
  7.     /**
  8.      *  1000元以内可以直接处理
  9.      * @param request
  10.      */
  11.     @Override
  12.     public void handlerRequest(Request request) {
  14.         if(RequestType.valueOf(request.getRequestType())!=null && request.getMoney()<=1000){
  16.             System.out.println("普通操作，输入支付密码即可");
  18.             System.out.println(name+":"+request.getRequestType() + ", 金额:"+request.getMoney() +" 处理完成");
  20.         }else {
  22.             //下个节点进行处理
  23.             if(superior!=null){
  24.                 superior.handlerRequest(request);
  25.             }
  26.         }
  28.     }
  29. }
  1. public class SecondRiskControlManager extends RiskControlManager {
  3.     public SecondRiskControlManager(String name) {
  4.         super(name);
  5.     }
  7.     /**
  8.      * 处理 1千到1万之间
  9.      * @param request
  10.      */
  11.     @Override
  12.     public void handlerRequest(Request request) {
  13.         if(RequestType.valueOf(request.getRequestType())!=null && request.getMoney()>1000 && request.getMoney()<10000){
  15.             System.out.println("稍大额操作，输入支付密码+短信验证码即可");
  17.             System.out.println(name+":"+request.getRequestType() + ", 金额:"+request.getMoney() +" 处理完成");
  19.         }else {
  21.             //下个节点进行处理
  22.             if(superior!=null){
  23.                 superior.handlerRequest(request);
  24.             }
  25.         }
  26.     }
  27. }
  2. public class ThirdRiskControlManager extends RiskControlManager {
  4.     public ThirdRiskControlManager(String name) {
  5.         super(name);
  6.     }
  8.     @Override
  9.     public void handlerRequest(Request request) {
  10.         if(RequestType.valueOf(request.getRequestType())!=null && request.getMoney()>10000){
  12.             System.out.println("大额操作，输入支付密码+验证码+人脸识别 ");
  14.             System.out.println(name+":"+request.getRequestType() + ", 金额:"+request.getMoney() +" 处理完成");
  16.         }else {
  17.             //下个节点进行处理
  18.             if(superior!=null){
  19.                 superior.handlerRequest(request);
  20.             }
  21.         }
  22.     }
  23. }

5.命令设计模式

  • 命令设计模式（Command Pattern）

    • 请求以命令的形式包裹在对象中，并传给调⽤对象。调 ⽤对象寻找可以处理该命令的对象，并把该命令传给相应的对象 执⾏命令，属于⾏为型模式
    • 命令模式是⼀种特殊的策略模式，体现的是多个策略执⾏的问题，⽽不是选择的问题

  • 应⽤场景

    • 只要是你认为是命令的地⽅，就可以采⽤命令模式
    • ⽇常每个界⾯、按钮、键盘 事件操作都是 命令设计模式

  • ⻆⾊

    • 抽象命令(Command)：需要执⾏的所有命令都在这⾥声明
    • 具体命令(ConcreteCommand)：定义⼀个接收者和⾏为之间的弱耦合，实现execute()⽅法，负责调⽤接收者的相应操作，execute()⽅法通常叫做执⾏⽅法。
    • 接受者(Receiver)：负责具体实施和执⾏⼀个请求，⼲活的⻆⾊，命令传递到这⾥是应该被执⾏的，实施和执⾏请求的⽅法叫做⾏动⽅法
    • 请求者(Invoker)：负责调⽤命令对象执⾏请求，相关的⽅法叫做⾏动⽅法
    • 客户端(Client)：创建⼀个具体命令(ConcreteCommand)对象并确定其接收者。

image.png

  1. //接受者，命令执⾏者
  2. public class Receiver {
  3.     public void doSomething() {
  4.             System.out.println("Receiver---doSomething");
  5.     }
  6. }
  1. //抽象命令
  2. public interface Command {
  3.     /**
  4.     执⾏动作
  5.     */
  6.     void execute();
  7. }
  1. //具体命令
  2. public class ConcreteCommand implements Command{
  3.     /**
  4.      对哪个receiver类进⾏命令处理
  5.     */
  6.     private Receiver receiver;
  8.     public ConcreteCommand(Receiver receiver) {
  9.             this.receiver = receiver;
  10.     }
  12.     /**
  13.     必须实现⼀个命令
  14.     */
  15.     @Override  
  16.     public void execute() {
  17.         System.out.println("ConcreteCommand---execute");
  18.         receiver.doSomething();
  19.     }
  20. }
  1. //请求者
  2. public class Invoker {
  3.     private Command command;
  5.     public Invoker(Command command){
  6.             this.command = command;
  7.     }
  8.     /*
  9.     执⾏命令
  10.     */
  11.     public void action(){
  12.         this.command.execute();
  13.     }
  14. }
  1. //使⽤
  2. public static void main(String[] args) {
  3.     //创建接收者
  4.     Receiver receiver = new Receiver();
  5.     //创建命令对象，设定它的接收者
  6.     Command command = new
  7.     ConcreteCommand(receiver);
  8.     //创建请求者，把命令对象设置进去
  9.     Invoker invoker = new Invoker(command);
  10.     //执⾏⽅法
  11.     invoker.action();
  12. }
  • 命令设计模式之智能家居控制案例实战
  • 业务需求

⽼王-搬新家了，他想实现智能家居，开发⼀个app，可以控制家⾥的家电，⽐如控制空调的开关、加热、制冷 等功能
利⽤命令设计模式，帮⽼王完成这个需求，注意：动作请求者就 是⼿机app, 动作的执⾏者是家电的不同功能

  1. public class ConditionReceiver {
  3.     public void on(){
  4.         System.out.println("空调开启了");
  5.     }
  7.     public void off(){
  8.         System.out.println("空调关闭了");
  9.     }
  11.     public void cool(){
  12.         System.out.println("空调开始制冷");
  13.     }
  15.     public void warm(){
  16.         System.out.println("空调开始制暖");
  17.     }
  18. }
  1. public interface Command {
  3.     /**
  4.      * 执行动作
  5.      */
  6.     void execute();
  8. }
  1. public class OnCommand implements Command{
  3.     /**
  4.      * 对哪个receiver 进行命令处理
  5.      */
  6.     private ConditionReceiver receiver;
  8.     public OnCommand(ConditionReceiver receiver){
  9.         this.receiver = receiver;
  10.     }
  12.     /**
  13.      * 必须实现一个命令的调用
  14.      */
  15.     @Override
  16.     public void execute() {
  18.         System.out.println("OnCommand -> execute");
  19.         receiver.on();
  21.     }
  22. }
  25. public class OffCommand implements Command{
  27.     /**
  28.      * 对哪个receiver 进行命令处理
  29.      */
  30.     private ConditionReceiver receiver;
  32.     public OffCommand(ConditionReceiver receiver){
  33.         this.receiver = receiver;
  34.     }
  36.     /**
  37.      * 必须实现一个命令的调用
  38.      */
  39.     @Override
  40.     public void execute() {
  42.         System.out.println("OffCommand -> execute");
  43.         receiver.off();
  45.     }
  46. }
  48. public class WarmCommand implements Command{
  50.     /**
  51.      * 对哪个receiver 进行命令处理
  52.      */
  53.     private ConditionReceiver receiver;
  55.     public WarmCommand(ConditionReceiver receiver){
  56.         this.receiver = receiver;
  57.     }
  59.     /**
  60.      * 必须实现一个命令的调用
  61.      */
  62.     @Override
  63.     public void execute() {
  65.         System.out.println("WarmCommand -> execute");
  66.         receiver.warm();
  68.     }
  69. }
  72. public class CoolCommand implements Command{
  74.     /**
  75.      * 对哪个receiver 进行命令处理
  76.      */
  77.     private ConditionReceiver receiver;
  79.     public CoolCommand(ConditionReceiver receiver){
  80.         this.receiver = receiver;
  81.     }
  83.     /**
  84.      * 必须实现一个命令的调用
  85.      */
  86.     @Override
  87.     public void execute() {
  89.         System.out.println("CoolCommand -> execute");
  90.         receiver.cool();
  92.     }
  93. }
  1. public class AppInvoker {
  4.     private Command onCommand;
  5.     private Command offCommand;
  7.     private Command coolCommand;
  8.     private Command warmCommand;
  11.     public void setOnCommand(Command onCommand) {
  12.         this.onCommand = onCommand;
  13.     }
  15.     public void setOffCommand(Command offCommand) {
  16.         this.offCommand = offCommand;
  17.     }
  19.     public void setCoolCommand(Command coolCommand) {
  20.         this.coolCommand = coolCommand;
  21.     }
  23.     public void setWarmCommand(Command warmCommand) {
  24.         this.warmCommand = warmCommand;
  25.     }
  27.     /**
  28.      * 开机
  29.      */
  30.     public void on(){
  31.         onCommand.execute();
  32.     }
  34.     /**
  35.      * 关机
  36.      */
  37.     public void off(){
  38.         offCommand.execute();
  39.     }
  41.     public void warm(){
  42.         warmCommand.execute();
  43.     }
  45.     public void cool(){
  46.         coolCommand.execute();
  47.     }
  49. }