观察者模式

观察者模式定义了对象间的一种一对多的组合关系，以便一个对象的状态发生变化时，所有依赖于它的对象都能得到通知并自动刷新。该模式必须包含两种角色：观察者和被观察者。

Observer

所有观察者的抽象，需要具备更新的功能。

Observer.java

public interface Observer {
    /**
     * 更新
     */
    void update();
}

Subject

主题，所有被观察者的抽象，需要具备添加观察者、移除观察者和通知观察者的功能。

Subject.java

public interface Subject {
    /**
     * 添加观察者
     * @param observer 观察者
     */
    void addObserver(Observer observer);

    /**
     * 移除观察者
     * @param observer 观察者
     */
    void removeObserver(Observer observer);

    /**
     * 通知观察者
     */
    void notifyObservers();
}

ConcreteSubject

具体主题（被观察者）类。

ConcreteSubject.java

import java.util.Vector;

public class ConcreteSubject implements Subject {
    private int state;
    private Vector<Observer> observers = new Vector<>();
    @Override
    public void addObserver(Observer observer) {
        this.observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        this.observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for(Observer observer : observers) {
            observer.update();
        }
    }
    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
    public int getState() {
        return this.state;
    }
}

ConcreteObserver

具体观察者类。

ConcreteObserver.java

public class ConcreteObserver implements Observer {
    ConcreteSubject subject;

    public ConcreteObserver(ConcreteSubject subject) {
        this.subject = subject;
        this.subject.addObserver(this);
    }

    @Override
    public void update() {
        System.out.println("收到状态变化：" + this.subject.getState());
    }
}

Demo

测试类，当被观察者设置新的state时，通知所有观察者。观察者可察觉到变化。

Demo.java

public class Demo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer = new ConcreteObserver(subject);
        subject.setState(10);
    }
}