设计模式-观察者模式

超、凢脫俗 2022-01-19 23:53 377阅读 0赞

观察者模式

引言

今天开车出去有事，还挺赶时间的，突然遇到了一个红灯，这红灯时间可真长，等了好久终于看到变绿灯了，赶紧开车过去。

正文

观察者模式是指多个对象之间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到它的通知，然后做出改变。

核心思想

通过对目标和观察者之间建立了一套触发机制，降低了两者间的耦合关系，因为这两者仅仅都是抽象耦合。

代码实现

讲解

  1. //抽象观察者
  2. public interface Observer {
  3.     void response();
  4. }
  5. 复制代码
  7. //抽象目标
  8. public abstract class Subject {
  9.     protected List<Observer> observers = new ArrayList<>();
  11.     public void add(Observer observer) {
  12.         observers.add(observer);
  13.     }
  15.     public void remove(Observer observer) {
  16.         observers.remove(observer);
  17.     }
  19.     //通知
  20.     public abstract void notifyObserver();
  21. }
  22. 复制代码
  24. //具体目标
  25. public class ConcreteSubject extends Subject {
  26.     @Override
  27.     public void notifyObserver() {
  28.         System.out.println("此时发生了一些变化...");
  29.         for (Object obj : observers) {
  30.             ((Observer) obj).response();
  31.         }
  32.     }
  33. }
  34. 复制代码
  36. //具体观察者
  37. public class ConcreteObserver implements Observer {
  38.     @Override
  39.     public void response() {
  40.         System.out.println("具体观察者对变化作出反应");
  41.     }
  42. }
  43. 复制代码

实例

  1. //抽象交通信号灯类（目标）
  2. public abstract class TrafficLights {
  3.     protected List<Driver> drivers = new ArrayList<>();
  5.     public void add(Driver driver) {
  6.         drivers.add(driver);
  7.     }
  9.     public void remove(Driver driver) {
  10.         drivers.remove(driver);
  11.     }
  13.     public abstract void notifyDriver();
  14. }
  15. 复制代码
  17. public class RedLight extends TrafficLights {
  18.     @Override
  19.     public void notifyDriver() {
  20.         System.out.println("红灯变成绿灯了...");
  21.         for (Driver driver : drivers) {
  22.             driver.response();
  23.         }
  24.     }
  25. }
  26. 复制代码
  28. //司机接口（观察者）
  29. public interface Driver {
  30.     void response();
  31. }
  32. 复制代码
  34. public class MeDriver implements Driver {
  35.     @Override
  36.     public void response() {
  37.         System.out.println("红灯告诉我变成绿灯了,我得开车走了");
  38.     }
  39. }
  40. 复制代码
  42. //调用
  43. public class Main {
  44.     public static void main(String[] args) {
  45.         TrafficLights redLight = new RedLight();
  46.         MeDriver meDriver = new MeDriver();
  47.         redLight.add(meDriver);
  48.         redLight.notifyDriver();
  49.     }
  50. }
  51. 复制代码

输出结果

  1. 红灯变成绿灯了...
  2. 红灯告诉我变成绿灯了,我得开车走了
  3. 复制代码

总结

观察者模式很好的处理了一对多对象之间的耦合关系，但并没有完全解除之间的依赖关系，处理不好可能会造成循环引用，同时如果观察者对象过多时，通知的发布会效率变低（参考一个高速堵车）。

发表评论

表情：
评论列表 （有 0 条评论，377人围观）

还没有评论，来说两句吧...

相关阅读

    相关 设计模式-观察者模式

    观察者模式 引言 > 今天开车出去有事，还挺赶时间的，突然遇到了一个红灯，这红灯时间可真长，等了好久终于看到变绿灯了，赶紧开车过去。 正文 观察者模式是指多

    超、凢脫俗超、凢脫俗/ 0 赞/ 378 阅读

    相关 设计模式-观察者模式

    观察者模式也叫订阅发布模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

    小灰灰小灰灰/ 0 赞/ 407 阅读

    相关 设计模式——观察者模式

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

    骑猪看日落骑猪看日落/ 0 赞/ 253 阅读

    相关 设计模式:观察者模式

    一.简介 > QT的信号槽就是观察者模式,当事件发生之后(比如按钮被点击)就会发出一个信号,这种信号类似广播没有目的.当对象对信号感兴趣,就会通过 connect() 函

    迷南。迷南。/ 0 赞/ 527 阅读

    相关 设计模式--观察者模式

    定义 在对象之间定义了一对多的依赖，当一方发生改变时，依赖它的对象都会受到通知并自动更新。 其实可以理解为消息发布者（被观察者）与订阅者（观察者），用户可以订阅或者取消

    一时失言乱红尘一时失言乱红尘/ 0 赞/ 596 阅读