JAVA设计模式--观察者

观察者模式 Observer

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。

　　这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。

观察者模式的组成

　　抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

　　抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

　　具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

　　具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

首先定义抽象的观察者：

package com.hfview.designMode.Observer;

public interface Observer {

      public void update(float temprature);
}

然后定义抽象的主题角色，即抽象的被观察者，在其中声明方法（添加、移除观察者，通知观察者）：

package com.hfview.designMode.Observer;

public interface Subject {

    public void registerObserver(Observer o);

    public void removeObserver(Observer o);

    public void notifyObservers();

}

然后定义具体的观察者：

package com.hfview.designMode.Observer;

public class ConcreteObserver implements Observer {

    private float temperature;
    private final Subject subject;

    /** * 默认构造，也让自己变成观察者 * @param subject */
    public ConcreteObserver(final Subject subject) {
        this.subject = subject;
        this.subject.registerObserver(this);
    }

    public float getTemperature() {
        return temperature;
    }

    public void setTemperature(final float temperature) {
        this.temperature = temperature;
    }

    /** * 观察者改变自己 */
    public void update(final float temperature) {
        this.temperature = temperature;
        System.out.println("temperature变成了"+temperature);
    }

    /** * 退出观察者 */
    public void exitObserver(){
        subject.removeObserver(this);
    }
}

之后是具体的主题角色：

package com.hfview.designMode.Observer;

import java.util.ArrayList;
import java.util.List;

public class ConcreteSubject implements Subject {

    private final List<Observer> observers;
    private float temperature;

    public float getTemperature()
    {
        return temperature;
    }

    private void temperatureChanged()
    {
        this.notifyObservers();
    }

    /** * 更改自己的状态，并且通知观察者 * @param temperature */
    public void setTemperature(final float temperature)
    {
        this.temperature = temperature;
        this.temperatureChanged();
    }

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

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

    public void removeObserver(final Observer o)
    {
        if (observers.indexOf(o) >= 0)
        {
            observers.remove(o);
        }
    }

    public void notifyObservers()
    {
        for (final Observer o : observers)
        {
            o.update(temperature);
        }
    }

}

总结

观察者模式的应用场景：

1、 对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。

2、 对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

观察者模式的优点：

1、 Subject和Observer之间是松偶合的，分别可以各自独立改变。

2、 Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。

3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。

观察者模式的缺陷：

1、 如果一个Subject被大量Observer订阅的话，在广播通知的时候可能会有效率问题。（毕竟只是简单的遍历）

参考博客地址：原博客链接