观察者模式

描述：多个对象对某一个主题感兴趣，当主题变化时，所有对这主题感兴趣的对象都能收到通知

场景：很多用户都订阅一篇新闻，当这篇新闻有变化时，订阅的用户都能收到通知

实现：

抽象一个观察者，它可以根据订阅的主题和状态值进行后续操作

interface Observer {
    void update(Subject subject, int val);
}

定义读者1

class ObserverOne implements Observer {

    @Override
    public void update(Subject subject, int val) {
        System.out.println(String.format("观察者1收到主题[%s]的值改变为[%d]", subject.toString(), val));
    }
}

定义读者2

class ObserverTwo implements Observer {

    @Override
    public void update(Subject subject, int val) {
        System.out.println(String.format("观察者2收到主题[%s]的值改变为[%d]", subject.toString(), val));
    }
}

抽象一个主题

abstract class Subject {

    private List<Observer> observers = new ArrayList<Observer>();

    void register(Observer observer) {
        this.observers.add(observer);
    }

    void remove(Observer observer) {
        this.observers.remove(observer);
    }

    void notify(int val) {
        for(Observer o : observers) {
            o.update(this, val);
        }
    };
}

定义一个新闻，读者1、2可以对其订阅

class NewsSubject extends Subject {

    String name;

    int val;

    NewsSubject(String name, int val) {
        this.name = name;
        this.val = val;
    }

    void change(int val) {
        int rawVal = this.val;
        this.val = val;
        System.out.println(String.format("[%s]的状态由[%d]变为[%d]",name, rawVal, val));
        notify(val);
    }

    @Override
    public String toString() {
        return name;
    }
}

读者1、2订阅了一条新闻，当新闻变动了，比如有新评论了，读者1，2都能收到通知

public class ObserverDemo {
    public static void main(String[] args) {
        Observer observerOne = new ObserverOne();
        Observer observerTwo = new ObserverTwo();
        NewsSubject subject = new NewsSubject("新闻", 1);
        subject.register(observerOne);
        subject.register(observerTwo);
        subject.change(10);
        subject.change(20);
    }
}

打印结果：

[新闻]的状态由[1]变为[10]
观察者1收到主题[新闻]的值改变为[10]
观察者2收到主题[新闻]的值改变为[10]
[新闻]的状态由[10]变为[20]
观察者1收到主题[新闻]的值改变为[20]
观察者2收到主题[新闻]的值改变为[20]