设计模式-观察者模式

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

# 观察者模式 #

## 引言 ##

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

## 正文 ##

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

## 核心思想 ##

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

## 代码实现 ##

讲解

//抽象观察者
    public interface Observer {
        void response();
    }
    复制代码

//抽象目标
    public abstract class Subject {
        protected List<Observer> observers = new ArrayList<>();
    
        public void add(Observer observer) {
            observers.add(observer);
        }
    
        public void remove(Observer observer) {
            observers.remove(observer);
        }
    
        //通知
        public abstract void notifyObserver();
    }
    复制代码

//具体目标
    public class ConcreteSubject extends Subject {
        @Override
        public void notifyObserver() {
            System.out.println("此时发生了一些变化...");
            for (Object obj : observers) {
                ((Observer) obj).response();
            }
        }
    }
    复制代码

//具体观察者
    public class ConcreteObserver implements Observer {
        @Override
        public void response() {
            System.out.println("具体观察者对变化作出反应");
        }
    }
    复制代码

实例

//抽象交通信号灯类（目标）
    public abstract class TrafficLights {
        protected List<Driver> drivers = new ArrayList<>();
    
        public void add(Driver driver) {
            drivers.add(driver);
        }
    
        public void remove(Driver driver) {
            drivers.remove(driver);
        }
    
        public abstract void notifyDriver();
    }
    复制代码

public class RedLight extends TrafficLights {
        @Override
        public void notifyDriver() {
            System.out.println("红灯变成绿灯了...");
            for (Driver driver : drivers) {
                driver.response();
            }
        }
    }
    复制代码

//司机接口（观察者）
    public interface Driver {
        void response();
    }
    复制代码

public class MeDriver implements Driver {
        @Override
        public void response() {
            System.out.println("红灯告诉我变成绿灯了,我得开车走了");
        }
    }
    复制代码

//调用
    public class Main {
        public static void main(String[] args) {
            TrafficLights redLight = new RedLight();
            MeDriver meDriver = new MeDriver();
            redLight.add(meDriver);
            redLight.notifyDriver();
        }
    }
    复制代码

## 输出结果 ##

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

## 总结 ##

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