Head First设计模式学习笔记——观察者模式

Head First设计模式学习笔记——观察者模式简单理解

问题来源：

    如何建立对象之间的一对多的依赖关系，使得当一个对象改变状态时，其他依赖它的对象都能收到通知并自动更新。比如，在下图中Subject（主题）和Observer1（观察者）、Observer2、Observer3存在一对多的依赖关系，当Subject的状态改变时，如何通知3个Observer更新各自的状态。观察者模式就是用于解决上述问题。

    在学习观察者模式前，先试着用普通方法解决这个问题，代码如下：

public class Subject {

    private int state; 
    private Observer1 observer1;
    private Observer2 observer2;
    private Observer3 observer3;
    // ...    

    public void stateChanged() {
        observer1.update(state);
        observer2.update(state);
        observer3.update(state);
    }
    // ...
}

   上述代码中，Subject类拥有3个成员变量Observer1、Observer2和Observer3，当Subject的状态改变时，执行stateChanged()方法，通过3个observer对象的update()方法更新状态。当Observer的数量少且不经常更新时，上述方法的确可以解决问题，但是当Observer数量大且经常更新时，就需要修改大量的代码了，可以说该方法无法动态地增加（或删除）Observer对象。因此，需要在Subject中添加管理Observer的方法，类图如下：

    

    对象使用Subject接口注册成为Observer（观察者），或者把自己从观察者中删除。每个Subject对应管理多个Observer，当Subject的状态改变时，通知Observer做相应的更新。完整的代码如下：

Subject.java：

public interface Subject {
    public void registerObserver(Observer o); //注册观察者
    public void removeObserver(Observer o);  //移除观察者
    public void notifyObservers(); //通知全部观察者改变状态
}

Observer.java:

public interface Observer {
    public void update(int state); //观察者更新自己的状态
}

ConcreteSubject.java:

import java.util.ArrayList;

public class ConcreteSubject implements Subject {
    private ArrayList observerList;
    private int state = 0;

    public ConcreteSubject() {
    	observerList = new ArrayList();
    }

    public int getState() {
        return this.state; 
    }

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

	public void registerObserver(Observer o) {
        observerList.add(o); 
    }
	
	public void removeObserver(Observer o) {
	    int i = observerList.indexOf(o);
	    if(i >=0) {
		    observerList.remove(i);	
	    } 
        
	}

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

Observer1.java:

public class Observer1 implements Observer {
    private int state = 0;
    private Subject subject;
    
    public Observer1(Subject subject) {
        this.subject = subject;
        subject.registerObserver(this);
    }

    public int getState() {
        return this.state;
    }

    public void update(int state) {
        this.state = state;
    }

}

Observer2.java:

public class Observer2 implements Observer {
    private int state = 0;
    private Subject subject;

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

    public int getState() {
        return this.state;
    }

    public void update(int state) {
        this.state = state;
    }

}

test.java:

public class test {

    public static void main(String[] args) {

        //实例化ConcreteSubject
        ConcreteSubject subject = new ConcreteSubject();

        //实例化 Observer1 和 Observer2
        Observer1 observer1 = new Observer1(subject);
        Observer2 observer2 = new Observer2(subject);

        System.out.println(subject.getState());
        System.out.println(observer1.getState());
        System.out.println(observer2.getState());

        //设置subject state的值为1
        subject.setState(1);
	
        System.out.println(subject.getState());
        System.out.println(observer1.getState());
        System.out.println(observer2.getState());

        //subject中删除observer2
        subject.removeObserver(observer2);
        subject.setState(2);//修改subject的state值为2
	
        System.out.println(subject.getState());
        System.out.println(observer1.getState());
        System.out.println(observer2.getState());
    }
}

运行结果如下：

    分析结果，初始时，subject、observer1和observer2的state均为0；当subject的state改为1时，observer1和observer2的state也更新为1； 之后，从subject中删除observer2，改变subject的state为2，此时observer1的state被更新为2，而observer2的state还是上一个结果1。

参考自：