JAVA观察者模式（Observable和Observer）

注：Observable和Observer源码复制于JDK，删掉了注释

首先看Observer类，它是一个接口

public interface Observer {
    void update(Observable o, Object arg);
}

再看Observable类

public class Observable {
    private boolean changed = false;

    private Vector obs;

    public Observable() {
        obs = new Vector();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length - 1; i >= 0; i--)
            ((Observer) arrLocal[i]).update(this, arg);
    }

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

它所表达的含义就是当被观察者所被关心的值发生变化时，通知观察者，并作出相应的行为

观察者类Server，实现Observer观察者接口

public class Server implements Observer {
    public void update(Observable o, Object arg) {
        Servable servable = (Servable) o;
        System.out.println("servable changed!");
        System.out.println(servable.getA());
    }
}

被观察者类Servable，继承自Observable类，是一个被观察者

public class Servable extends Observable {
    private int a = 4;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
        setChanged();
        notifyObservers();
    }

}

现将观察者添加进被观察者的列表

        Servable servable = new Servable();
        Observer server = new Server();
        servable.addObserver(server);

当a变化时，首先改变改变状态将changed变为true；然后调用notifyObservers方法通知各个观察者

观察者们关注于其a的值的变化

测试类Test

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Servable servable = new Servable();
        Observer server = new Server();
        servable.addObserver(server);
        servable.setA(5);
    }

}

当被观察者servable的A变化时，它通知它所添加的所有观察者，每一个观察者按照自己的意愿执行自己的update方法

这个例子中，观察者server执行了打印

运行结果：

servable changed!
5

“好莱坞原则”：不要给我们打电话，我们会给你打电话(don‘t call us, we‘ll call you)。

注：以下为笔者理解，如有误请谅解

好莱坞明星都是大牌，请他拍戏的人很多，所以不要打电话来问我有没有档期，留下你的电话，有空时我会打电话给你，请他拍戏的人只需要被动等待就可以。

这里的明星就相当于被观察者，请他拍戏的人相当于观察者，观察者关注他有没有档期。观察者不需要时时去问被观察者有没有档期，有档期时，明星会setChanged(),改变档期状态，并且notifyObservers(),通知关注自己，请自己拍戏的人。请自己拍戏的人再做出相应的动作。