一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第3天，点击查看活动详情。

定义

定义了对象之间的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者都会收到通知并更新。

观察者模式主要有两个角色

Subject 观察主题对象，也可以叫被观察或者被订阅对象 Observer 观察者或者订阅者对象，当Subject有变动，就会通知到每一个Observer。

案例

Subject 主题对象

主题对象是一个抽象类，抽象类中需要包括订阅、取消订阅、以及通知变动三个方法。

interface Subject{
    //订阅操作
    void attach(Observer observer);
    //取消订阅
    void detach(Observer observer);
    //通知变动
    void notifyChange(Object obj);
}

Observer 观察者

interface Observer{
    //接收变动通知
    void updata(Object obj);
}

实现主题对象

class Subject1 implements Subject{
    private List<Observer> observerList=new ArrayList<>();

    @Override
    public void attach(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void notifyChange(Object objs) {
        for (Observer o:observerList) {
            o.updata(objs);
        }
    }
}

定义两个订阅者对象

class Observer1 implements Observer{

    public void updata(Object obj) {
        System.out.println("observer1-接收到了通知"+obj);
    }
}

class Observer2 implements Observer{

    public void updata(Object obj) {
        System.out.println("observer2接收到了通知"+obj);
    }
}

测试

public static void main(String[] args) {
    Subject1 subject1=new Subject1();
    Observer1 observer1=new Observer1();
    Observer2 observer2=new Observer2();
    subject1.attach(observer1);
    subject1.attach(observer2);
    subject1.notifyChange("new");
    System.out.println("================");
    subject1.detach(observer1);
    subject1.notifyChange("new2");
}

执行结果

通过执行结果，我们可以看到，当observer1和observer2都订阅之后，然后通过调用notifyChange就可以通知订阅信息，当把observer1取消订阅之后，再次通知信息，就只有observer1可以收到信息了。

使用java帮我们实现观察者模式

创建subject 继承 Observable

class Subjects extends Observable{
    public void toChange(Object object){
        setChanged();
        notifyObservers(object);
    }
}

创建两个订阅者

class subObserver1 implements Observer{
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("this is sub1:"+arg);
    }
}

class subObserver2 implements Observer{
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("this is sub2:"+arg);
    }
}

测试

public static void main(String[] args) {
    Subjects subjects=new Subjects();
    subObserver1 subObserver1=new subObserver1();
    subObserver2 subObserver2=new subObserver2();
    subjects.addObserver(subObserver1);
    subjects.addObserver(subObserver2);
    subjects.toChange("第一次消息");
    System.out.println("============================");
    subjects.deleteObserver(subObserver1);
    subjects.toChange("第二次消息");
    subjects.notifyObservers();
}

执行结果

这样是不简便很多。