设计模式（二）观察者模式

1. 定义
   观察者模式定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。
2. 设计原则
   为了交互对象之间的松耦合设计而努力。
3. UML
   
4. 实现

/**
 * 接口-主题
 */
public interface Subject {
    /**
     * 订阅主题
     *
     * @param o
     */
    public void registerObserver(Observer o);

    /**
     * 取消对主题的订阅
     *
     * @param o
     */
    public void removeObserver(Observer o);

    /**
     * 广播通知
     */
    public void notifyObservers();
}

/**
 * 接口-观察者
 */
public interface Observer {
    /**
     * 获取主题更新
     */
    public void update();
}

/**
 * 接口实现类-具体的主题
 */
public class ConcreteSubject implements Subject {
    /**
     * 记录观察者的数据结构
     */
    private List<Observer> observers;

    public ConcreteSubject() {
        observers = new ArrayList<Observer>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++) {
            Observer observer = observers.get(i);
            observer.update();
        }
    }
}

/**
 * 接口实现类-具体的观察者
 */
public class ConcreteObserver implements Observer {

    /**
     * 这里保存对subject的引用，是因为如果以后要取消注册，
     * 已经有了对subject的引用会比较方便。
     */
    private Subject subject;

    public ConcreteObserver(Subject subject) {
        this.subject = subject;
        subject.registerObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Hello World !");
    }
}

/**
 * 测试类-观察者模式
 */
public class ObserverTest {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer o1 = new ConcreteObserver(subject);
        Observer o2 = new ConcreteObserver(subject);
        Observer o3 = new ConcreteObserver(subject);
        subject.notifyObservers();
    }
}

运行结果：

参考资料：
《Head First设计模式》