设计模式-10.观察者模式

定义：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

使用场景：一个对象变化将导致其他一个或多个对象发生变化。

实现：定义抽象主题类，包含一个list类型的观察者列表，定义增加和删除观察者的方法和状态改变方法以及通知观察者的notify方法，用来循环遍历调用观察者的更新方法。定义观察者接口（为什么用接口？因为观察者可能是五花八门的类），其中定义update方法。

优点：观察者和被观察者是抽象耦合的，依赖倒转

不足：观察者的通知方法不一定就是统一的更新，解决方法就是委托模式，他是C#中的语言级特性，java并没有对应的实现，但我们可以通过动态代理来实现委托。具体后面说。

代码示例：老师来啦！！！！

**
 * 抽象主题类
 * @author liuhao
 *
 */
public abstract class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    
    public void add(Observer observer) {
        observers.add(observer);
    }
    
    public void delete(Observer observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

/**
 * 學生臥底
 * @author liuhao
 *
 */
public class UndercoverStudent extends Subject {
    
    //全部繼承自父類
}

/**
 * 观察者接口
 * @author liuhao
 *
 */
public interface Observer {
    void update();
}

/**
 * 观察者实现类-学生
 * @author liuhao
 *
 */
public class Student implements Observer {
    private Subject subject;
    private String name;

    public Student(Subject subject, String name) {
        super();
        this.subject = subject;
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(subject.getState() + "," + name + "注意隐蔽！");
    }

}

public class Main {

    public static void main(String[] args) {
        UndercoverStudent subject = new UndercoverStudent();
        
        subject.add(new Student(subject, "小明"));
        subject.add(new Student(subject, "小李"));
        
        subject.setState("老師來了");
        subject.notifyObservers();
    }

}

结果：