设计模式学习（二）-- 观察者模式 Observer Pattern

观察者模式：定义了对象之间的一对多依赖，这样当一个对象状态改变的时候，它的所有依赖者都会收到通知并自动更新。

设计原则：为了交互对象之间的松耦合设计而努力。
松耦合的设计让对象之间的依赖降到最低，这样便于建立更加有弹性的系统，应对变化。

实现观察者模式的方法不止一种，但是包含Subject和Observer接口的设计实现最常见。

主题只需要知道观察者实现了观察者接口Observer，不需要知道观察者的具体类是谁，做了什么。主题唯一依赖的是一个实现了观察者Observer接口的对象列表，可以随时增加，删除观察者，并方便地通知所有列表中的观察者。
观察者只需要持有一个主题的对象，用于注册成为主题的观察者，这样就可以接受到主题状态改变的通知。

观察者模式类图：

主题是拥有数据或者状态的对象，观察者依赖主题来获取数据或者状态的改变。一个主题可以有多个观察者依赖它。主题负责在数据或者状态改变的时候，将改变通知所有依赖它的观察者。观察者必须注册具体主题，以便接受更新。

代码实现：

/**
 *
 * @author Yves
 */
public interface Subject{
        public void Register(Observer o);
        public void Remove(Observer o);
        public void NotifyObservers();
}

这是主题接口，对象使用此接口注册为观察者，或者把自己从观察者中删除。实现此接口的具体主题还必须实现NotifyObservers()方法用于在状态改变时通知所有的观察者。

class MySubject implements Subject {

    private String name;
    private int age;
    //observers list
    private ArrayList observers;   

    public MySubject() {
        //create observers list in the Contruct method.
        observers = new ArrayList();
    }

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

    @Override
    public void Remove(Observer o) {
        if (observers != null && !observers.isEmpty() && observers.contains(o)) {
            observers.remove(o);
        }
    }

    @Override
    public void NotifyObservers() {
        for (Object observer : observers) {
            Observer ob = (Observer) observer;
            ob.Update(name, age);
        }
    }

    public void ChangeDate(String name, int age) {
        this.SetName(name);
        this.SetAge(age);
        //notify all observers
        this.NotifyObservers();
    }

    public void SetName(String name) {
        this.name = name;
    }

    public void SetAge(int age) {
        this.age = age;
    }
}

具体主题类实现主题接口Subject，提供注册和删除观察者的方法，以及状态改变时通知所有观察者的方法。此处具体主题类维护一个ArrayList observers用来记录所有注册的观察者，以便实现注册、删除和通知观察者的方法。此外，具体主题类是拥有数据的对象，提供设置和获取这些数据的方法。ChangeDate(String name, int age)方法改变数据状态并且调用NotifyObservers()通知该主题维护的所有观察者。NotifyObservers()会调用每个观察者的Update()方法来实现数据状态改变的通知。

/**
 *
 * @author Yves
 */
 public interface Observer{
        public void Update(String name, int age);
 }

所有潜在观察者必须实现观察者接口，这个接口只有一个Update()方法，当主题状态改变时它被调用。

class ObserverA implements Observer {

    private String name;
    private int age;
    private MySubject mySubject;

    public ObserverA(MySubject mySubject) {
        this.mySubject = mySubject;
        //Register this observer to the observer list of Subject object.
        this.mySubject.Register(this);
    }

    @Override
    public void Update(String name, int age) {
        this.name = name;
        this.age = age;

        this.Display();
    }

    public void Display() {
        System.out.println("User name is: " + name + ", User age is: " + age);
    }

}

具体观察者实现观察者接口Observer，实现Update方法用于在主题的数据状态改变时更新这些数据状态。具体观察者必须注册主题，才能接收主题的更新通知。此处观察者持有一个具体主题的对象MySubject mySubject，在构造函数里面注册成为MySubject主题的观察者。

public class ObserverPattern {

    public static void main(String args[]){
        MySubject mys = new MySubject();
        ObserverA oba = new ObserverA(mys);
        //register an observer, THIS ACTIION is better done in the Observer class.
        //mys.Register(oba);
        //data change in MySubject, will notify all observers
        mys.ChangeDate("Yves", 18);
        //observers show the data
        oba.Display();
    }
}

注意：代码的实现不能依赖于观察者被通知的次序。因为一旦主题/观察者的实现改变了，通知的次序就会改变，依赖于某一特定实现的通知次序，是错误的。

Java API 内置观察者模式：java.util.Observable类和java.util.Observer为开发者接口提供了观察者模式。Observable类就是主题，具体的主题类需要继承Observable类。

由于Observable是一个类，所以具体主题就不能同时拥有Observable类和另一个超类的行为。