秋招突击——7/15、7/20——设计模式知识点补充——观察者模式、模板模式

引言

• 这里给出之前的学习链接

  • 适配器模式、代理模式、装饰器模式学习链接
  • 单例模式、依赖倒转原则、工厂方法模式
  • 简单工厂模式、策略模式

• 真是不长记性，看你最后一篇的结尾，说设计模式过一段时间再来看，结果就知道，这个没有看！笑死我了，又被人家拷问到了，然后就不会了吧！
  

• 现在就是回来填坑，还是按照之前的思路，基础知识加上面试题目的形式。

• 下述内容是在来自《大话设计模式》

正文

观察者模式

• 定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
  • 这个主题对象在状态发生变化时，会通知所有观察者对象，是他们能够自动更新自己！

书中样例——炒股事件Java代码版

• 前台对象将老板来公司的事件通知所有的同事。

import java.util.ArrayList;
import java.util.List;


class Main{

// 通知者接口，也就是秘书的接口
    interface Subject{
        void attach(Observer observer);  // 增加通知者
        void detach(Observer observer);  // 删除通知者
        void signal();
        String getAction();
        void setAction(String action);
    }



    // 秘书对象通知员工
    static class Secretary implements Subject{
        // 需要通知同事相关事宜，所以需要保存同事的联系方式
        private List<Observer> observers = new ArrayList<>();
        private String action;

        // 增加需要通知的同事方法
        @Override
        public void attach(Observer observer){
            observers.add(observer);
        }

        @Override
        public void detach(Observer observer) {
            // 删除特定员工通知
            observers.remove(observer);
        }

        // 同时对应的同事，老板来了
        @Override
        public void signal(){
            for(Observer o:observers){
                o.update();
            }
        }

        @Override
        public String getAction(){
            return action;
        }

        @Override
        public void setAction(String action){
            this.action = action;
        }
    }

    // 老板通知的情况
    static class Boss implements Subject {

        @Override
        public void attach(Observer observer) {

        }

        @Override
        public void detach(Observer observer) {

        }

        @Override
        public void signal() {

        }

        @Override
        public String getAction() {
            return "";
        }

        @Override
        public void setAction(String action) {

        }
    }

    abstract static class Observer{
            protected Subject subject;
            protected String name;

            // 构造函数
            public Observer(Subject subject, String name){
                this.subject = subject;
                this.name = name;
            }

            public abstract void update();
    }

    // 摸鱼讨论股票的同事
    static class StockObserver extends Observer{

        // 构造函数
        public StockObserver(String name, Secretary sub){
            super(sub, name);
        }

        // 同事接收到通知后的处理方法
        @Override
        public void update(){
            // 前台汇报具体的事宜，告诉员工某些事发生了，继续工作
            System.out.println(subject.getAction() + name + "关闭股票行情，继续工作！");
        }
    }

    // 看NBA的同事
    static class NBAObserver extends Observer{

        // 构造函数
        public NBAObserver(String name, Secretary sub){
            super(sub, name);
        }

        // 同事接收到通知后的处理方法
        @Override
        public void update(){
            // 前台汇报具体的事宜，告诉员工某些事发生了，继续工作
            System.out.println(subject.getAction() + name + "关闭NBA直播，继续工作！");
        }
    }

    public static void main(String[] args){
        // 前台小姐童子喆
        Secretary tongzizhe = new Secretary();

        // 看股票的同事
        StockObserver tongshi1 = new StockObserver("魏关姹", tongzizhe);
        StockObserver tongshi2 = new StockObserver("易管查", tongzizhe);

        // 看NBA的同事
        NBAObserver tongshi3 = new NBAObserver("易管查", tongzizhe);

        // 前台记下了老板回来了
        tongzizhe.setAction("老板回来了！");

        // 员工看到前台的动作，开始干活
        tongzizhe.attach(tongshi1);
        tongzizhe.attach(tongshi2);
        tongzizhe.attach(tongshi3);

        // 发现老板回来
        tongzizhe.signal();
    }
}

• 下述类图

具体定义

• 定义了一种一对多的依赖关系，让多个观察者对象（上文中的同事）同时监听某一个主题对象（上文中的前台秘书）。
  • 这个主题对象在状态发生变化是，会通知所有观察者对象，让他们自动更新自己。

结构图

Subject类（通知类）

• 将所有的对观察者对象的引用保存在一个聚集中，每一个通知者可以有任意数量的观察者。
  • 抽象主题提供一个接口，可以增加和删除观察者对象。

Observer类

• 观察者抽象类，所有具体观察者定义的一个接口，得到通知后更新自己
  • 包含update方法，更新方法

ConcreteSubject类（具体通知者）

ConcreteObserver类

• 具体观察者

客户端代码

观察者模式特点

• 解决一个系统分割成一系列相互协作的类的副作用，降低多个协作类的耦合性。
• 具体使用场景
  • 当一个对象的改变需要同时改变其他对象的时候，而且不知道具体有多少对象有待改变时

本质

• 接触耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，是的各自的变化都不影响另外一边的变化。

模板模式

• 形象定义
  • 当我们要完成某一个细节层次一致的过程或者一系列步骤，但其个别步骤在更详细的层面上的实现可能不同时，通常考虑使用模板的方法来处理。
  • 考试试卷每一个人都是相同的，抽象一个模板，每一个人只需要继承并作少量修改即可

具体定义

• 定义一个操作中的算法的股价，而将一些步骤延迟到子类中
  • 模板方法使得子类可以不改变一个算法的结构，就能够重定义该算法的某些特定的步骤
  • 典型应用，Java中的AQS自定义

• AbstractClass抽象类
  • 是一个抽象模板，定义并实现了一个模板方法
  • 模板方法一般是一个具体的方法，给出了一个顶级逻辑的骨架，具体实现步骤推迟到子类中实现。

• ConcreteClass具体类方法
  • 实现父类所定义的一个或者多个抽象方法
  • 每一个AbstractClass可以有任意多个ConcreteClass与之相对应，每一个Concreteclass都可以给出这些抽象方法的不同实现，使得顶级逻辑的实现各不相同。

客户端调用

模板方法模式特点

• 优势
  • 将不变的行为搬移到超类，去除子类中的重复代码
    • 当不变和可变的行为在子类实现中混合在一起的时候，不变的行为会在子类中重复出现，通过模板方法模式，将这些行为搬到单一的地方，帮助子类摆脱不变行为的纠缠。

面试题

说一说观察者模式

• 观察者模式主要用于处理对象间的一对多的关系，是一种对象行为模式
• 应用场景：
  • 当一个对象状态发生变化，所有该对象的关注者均能收到状态变化的通知，以进行相应的处理。

• 主要构成
  • Subject
    • 抽象被观察者，仅提供注册和删除观察者对象的接口声明
  • concreteSubject
    • 具体被观察者，收集了所有需要被通知的观察者，可以同态增删集合中的观察者。
    • 当状态发生变化时，会通知所有的观察者对象。
  • Observer
    • 抽象观察者，为所有观察者定义获得通知的统一接口
  • ConcreteObserver
    • 观察者对象，关注对象为Subject，能够接受Subject变化时发生的通知并更新自身的状态。

观察者模式的优缺点

• 优点
  • 被观察者和观察者之间时抽象耦合的
  • 对象之间的耦合度较低，两者的关联仅仅在于消息的通知。
  • 被观察者无需关心他的观察者
  • 支持广播通信。
• 缺点
  • 观察者只知道被观察者对象发生了变化，但不知道变化的过程和原因
  • 如果观察者和被观察者之间产生循环依赖，或者消息传递链路形成闭环，会导致无限循环。

项目中哪些地方用到了观察者模式

• 支付场景下，用户购买一件商品，支付成功后，第三方会回调自身，这时会执行许多额外的逻辑，这些逻辑都是观察者模式。

总结

• 看着一天，是真的累呀，不想看了，上午刷题，下午看项目，又看到一个自己不会的知识点，在这补知识点，真是累呀，一点都不轻松呀，找工作也是的！
• 终于看完了，今天甚是不在状态，后续需要用到什么模式，我再学吧，目前来看，在学习中接触到的模式都学过了，联系过了！