观察者模式

1.观察者模式概念

当一个对象存在一对多的关系的时候，则可以使用观察者模式（Observer Pattern）。比如，当一个对象发生改变的时候，所以依赖这个对象的对象都会接收到通知。观察者模式属于行为型模式。

2.观察者模式作用

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

3.何时使用

一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

4.优点和缺点

优点
1）观察者和被观察者是抽象耦合的。
2）建立一套触发机制。
缺点
3）如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
4）如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
5）观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

5.例子解析

观察者模式类图

抽象观察者:

public interface Observer {
    public void update(Object object);
}

具体观察者:
具体观察者一：

public class OberverOne implements Observer{

    @Override
    public void update(Object object) {
        Weather weather = (Weather) object;
        System.out.println("OberverOne检测到气候改变================");
        System.out.println("OberverOne--温度："+weather.getTemperatrue());
        System.out.println("OberverOne--气压："+weather.getPressure());
        System.out.println("OberverOne--湿度："+weather.getHumidity());
    }

}

具体观察者二：

public class OberverTwo implements Observer{

    @Override
    public void update(Object object) {
        Weather weather = (Weather) object;
        System.out.println("OberverTwo检测到气候改变================");
        System.out.println("OberverTwo--温度："+weather.getTemperatrue());
        System.out.println("OberverTwo--气压："+weather.getPressure());
        System.out.println("OberverTwo--湿度："+weather.getHumidity());
    }
}

被观察者（主题）：
可以看到，这里并没有按照类图将被观察者设计为一个接口，Java JDK也提供观察者模式接口，java.util.Observable就是被观察者，这个类也没有被设计为一个接口，而是一个类。虽然在设计模式中，为了实现程序可拓展，易维护，通常建议多用组合，少用继承，但这只是一个理论，要根据具体情况使用设计模式，只要满足需求，我们又何必多做功夫。而且《Head First Design Patterns》中也说到了，书中提到的设计模式，多多少少会有违背设计模式原则的地方。

public class Observed {

    private ArrayList observers = new ArrayList();

    public boolean attach(Observer observer) {
        return observers.add(observer);
    }
    
    public boolean remove(Observer observer)
    {
        return observers.remove(observer);
    }

    public void notifyAllObservers(Object object) {
        for (Observer observer : observers) {
            observer.update(object);
        }
    }
}

继承了被观察者的具体类：

public class WeatherData extends Observed {

    private Weather weather;

    public WeatherData() {
        weather = new Weather();
    }

    public void measureNotifyChanged() {
        notifyAllObservers(weather);
    }

    public void setMeasureElement(float temperatrue, float humidity,
            float pressure) {
        this.weather.setTemperatrue(temperatrue);
        this.weather.setHumidity(humidity);
        this.weather.setPressure(pressure);
        measureNotifyChanged();
    }
}

数据实体：

public class Weather {
    private float temperatrue;
    private float humidity;
    private float pressure;
    public float getTemperatrue() {
        return temperatrue;
    }
    public void setTemperatrue(float temperatrue) {
        this.temperatrue = temperatrue;
    }
    public float getHumidity() {
        return humidity;
    }
    public void setHumidity(float humidity) {
        this.humidity = humidity;
    }
    public float getPressure() {
        return pressure;
    }
    public void setPressure(float pressure) {
        this.pressure = pressure;
    }
}

客户端：

public class Test {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        OberverOne oberverOne = new OberverOne();
        OberverTwo oberverTwo = new OberverTwo();
        weatherData.attach(oberverOne);
        weatherData.attach(oberverTwo);
        while (true) {
            System.out.println("请选择模式 1.设置监听 2.改变数据");
            Scanner scanner = new Scanner(System.in);
            String temp = scanner.next();
            if (temp.equals("1")) {
                int temp2 = scanner.nextInt();
                if (temp2 == 1) {
                    if (weatherData.attach(oberverOne)) {
                        System.out.println("OberverOne监听成功！");
                    }else
                        System.out.println("OberverOne监听失败！");
                }else if (temp2 == -1) {
            
                    if (weatherData.remove(oberverOne)) {
                        System.out.println("OberverOne取消监听成功！");
                    }else
                        System.out.println("OberverOne取消监听失败！");
                }else if (temp2 == 2) {
                    if (weatherData.attach(oberverOne)) {
                        System.out.println("OberverTwo监听成功！");
                    }else
                        System.out.println("OberverTwo监听失败！");
                }else if (temp2 == -2) {
                    if (weatherData.remove(oberverOne)) {
                        System.out.println("OberverTwo取消监听成功！");
                    }else
                        System.out.println("OberverTwo取消监听失败！");
                }
            }else if (temp.equals("2")) {
                System.out.println("请输入温度，气压，湿度：");
                
                float temperatrue = scanner.nextFloat();
                float humidity = scanner.nextFloat();
                float pressure = scanner.nextFloat();
                weatherData.setMeasureElement(temperatrue, pressure, humidity);
            }
        }

    }
}

6.调用JDK内部观察者例子

观察者就没什么好说的了，直接实现java.util.Obserser接口,重写update（）方法即可：

public class CurrentConditionDisplay implements Observer {

    private Weather weather;
    public CurrentConditionDisplay() {
    }
    public void display(Weather weather) {
        System.out.println("Current condition: "+weather.getTemperatrue()+"F degree and humidity: "+weather.getHumidity()+"% humidity");
    }
    public void update(Observable o, Object arg) {
        weather = (Weather) arg;
        this.display(weather);
        
    }
}

被观察者除了继承java.util.Observable，还需要做两个步骤：
1）先调用setChange(),标记状态已改变的事实。
2）然后调用两个notifyObserver中的一个：

public class WeatherData extends Observable {

    private Weather weather;
    public WeatherData() {
        weather = new Weather();
    }
@Override
public void notifyObservers(Object arg) {
    // TODO Auto-generated method stub
    super.notifyObservers(weather);
}

    public void measureNotifyChanged()
    {   
        this.setChanged();
        notifyObservers();
    }
    
    public void setMeasureElement(float temperatrue,float humidity,float pressure)
    {
        this.weather.setTemperatrue(temperatrue);
        this.weather.setHumidity(humidity);
        this.weather.setPressure(pressure);
        measureNotifyChanged();
    }
}

详细代码可以通过文章结尾提供的地址下载源码，查看项目下的com.lgy.test.four包的内容。
notifyObserver()或notifyObserver(Object object)

7.总结

设计模式六大原则：
1、开闭原则（Open Close Principle）
开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
3、依赖倒转原则（Dependence Inversion Principle）
这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
5、迪米特法则，又称最少知道原则（Demeter Principle）
最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。
原则毕竟是理论，很多时候要根据具体情况来使用这些原则，不要生搬硬套，强迫一定要符合这个原则，不要忘了最初的目的，我们只是为了让程序更好维护罢了。

8.源码下载

http://download.csdn.net/detail/lgywsdy/9748282

9.参考文章

http://www.runoob.com/design-pattern/observer-pattern.html