观察者模式学习总结

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

就是说在一对多的对应关系中，一个对象的变化会导致一系列对象的响应的变化。
那如何去实现呢？我们想到的一定是接口，主对象去调用一系列从对象实现的相同接口。
要做到这一点，除了从对象都要去实现接口以外，要把这些对象都加到主对象中，让主对象来遍历调用。

那么不如将主对象中对从对象的添加删除和遍历都抽象出来。看代码
先看从对象接口：

public interface Observer {

    void update();
}

再看主对象抽象

public abstract class Subject {
    protected List<Observer> observers = new ArrayList<Observer>();


    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifier() {
        for(Observer observer : observers) {
            observer.update();
        }
    }

}

notifier函数就是遍历功能实现。
不需要关心具体的那个从对象被通知到了，主要将加入主对象队列的从对象实现的接口都遍历一遍，这就实现了通知所有从对象的功能。

来看具体主对象代码，这里我没有将具体主对象的属性放到抽象里面是为了说明，Subject也是一个接口，它就是为了添加从对象和遍历用的。

public class ConcreteSubject extends Subject {
    private String subjectState;

    public ConcreteSubject(String subjectState) {
        this.subjectState = subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

    public String getSubjectState() {
        return subjectState;
    }
}

看从对象实现接口代码：

public class ConcreteObserver implements Observer {
    private String name;
    private String observerState;
    private ConcreteSubject subject;

    public ConcreteObserver(String name, ConcreteSubject subject) {
        this.name = name;
        this.subject = subject;
    }

    public void setObserverState(String observerState) {
        this.observerState = observerState;
    }

    public String getObserverState() {
        return observerState;
    }

    @Override
    public void update() {
        System.out.println("老师" + subject.getSubjectState() + " " + name + "不要" + getObserverState() + "了！");
    }
}

ConcreteObserver对ConcreteSubject的观察：subject.getSubjectState()
并实现了Update接口。

看主函数代码：

ConcreteSubject teacher = new ConcreteSubject("走下讲台看看");
ConcreteObserver student1 = new ConcreteObserver("小伟",teacher);
student1.setObserverState("看nba");
ConcreteObserver student2 = new ConcreteObserver("小李",teacher);
student2.setObserverState("刷微博");
teacher.attach(student1);
teacher.attach(student2);
teacher.notifier();

student1和student2都实现了update接口；
teacher-ConcreteSubject实现了subject接口，并将student1和student2加入了接口中的teacher-ConcreteSubject的List供teacher-ConcreteSubject的notifier调用。

观察者的观察就是获得具体对象的状态：subject.getSubjectState()
而具体对象的通知，就是Subject的notifier接口调用Observer的update接口。
完美符合依赖倒转原则的按接口编程思想。

补充：在学习《重构》时，在8.6节，Duplicate Observed Data（复制“被监视数据”）时，观察者模式用于将客户端包含的数据独立出来，并保持与业务逻辑数据同步的情况。java.util中实现了Observable和Observer来个接口，只要去调用就可以了。看下面的链接：设计模式之观察者模式(Observable与Observer)