Java设计模式之Observer

1.概念
observer模式定义对象间的一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。从名字上可以清楚的看出两者在Observer 设计模式中分别扮演的角色：Observer是观察者角色，Observable是被观察目标(subject)角色。
2.实例
该实例模拟了烧水的过程，涉及三个对象，Heater(热水器),Display（显示器）,Alarm(报警器).
   模拟过程：为了便于运行，水的初始化温度为90，沸点为95，显示器依据热水器显示温度，显示器显示温度为95时，报警器开始报警。明显可以看出Heater是subject ,Display 是它的 Obsrver，同时Display亦是suject，因为它要被报警器观察，所以Alarm是Display的Observer.
   实现过程：
a.Heater.java

import java.util.Observable;

public class Heater extends Observable {

	private int temperature;

	public int getTemperature() {
		return temperature;
	}
	public void setTemperature(int temperature) {
		this.temperature = temperature;
	}
	public void boilWater() {
		for (int i = 90; i < 100; i++) {
			temperature = i;
			this.setChanged();
			this.notifyObservers();
		}
	}
}

b.Display.java

import java.util.Observable;
import java.util.Observer;

public class Display extends Observable implements Observer {

	private String status = "未开";

	public void setStatus(String status) {
		this.status = status;
	}
	public void displayTemputer(int temperature) {
		if (temperature > 95) {
			this.setStatus("沸腾");
			this.setChanged();
			this.notifyObservers();
		}
		System.out.println("状态：" + status + " 现在温度：" + temperature + "");
	}
	public void update(Observable o, Object arg) {
		displayTemputer(((Heater) o).getTemperature());//这里不是很好
	}
}

c.Alarm.java

import java.util.Observable;
import java.util.Observer;

public class Alarm implements Observer {

	public void makeAlarm() {
		System.out.println("嘀嘀嘀...水已经烧开 ");
	}
	public void update(Observable o, Object arg) {
		makeAlarm();
	}
}

d.测试类testObserver.java

public class testObserver {

	public static void main(String[] args) {
		Heater header = new Heater();
		Display display = new Display();
		Alarm alarm = new Alarm();
		header.addObserver(display);
		display.addObserver(alarm);
		header.boilWater();
	}
}

e.运行结果：

引用

状态：未开 现在温度：90
状态：未开 现在温度：91
状态：未开 现在温度：92
状态：未开 现在温度：93
状态：未开 现在温度：94
状态：未开 现在温度：95
嘀嘀嘀...水已经烧开
状态：沸腾 现在温度：96
嘀嘀嘀...水已经烧开
状态：沸腾 现在温度：97
嘀嘀嘀...水已经烧开
状态：沸腾 现在温度：98
嘀嘀嘀...水已经烧开
状态：沸腾 现在温度：99

3.总结， 观察者模式的应用场景：

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

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

观察者模式的优点：

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

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

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

观察者模式的缺陷：

1、 松偶合导致代码关系不明显，有时可能难以理解。(废话)

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

评论

10 楼 litianyi520 2010-01-31  

例子有点别扭，不够典型

9 楼 ianzhang 2009-11-19  

<p><br>observer模式定义对象间的<span style="background-color: #ffff00;">一对多</span>的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动 <br><br><br><span style="font-size: medium;"><strong><span style="color: #ff0000;">如果多个对象更新后需要通知另外一个对象，算什么模式？</span></strong></span></p>
<p> </p>

8 楼 peirubing 2009-11-02  

学习了。。。

7 楼 xucunliang 2009-10-09  

同意ziyu_1的观点

6 楼 zjutsoft 2009-09-16  

这个设计模式。比较实用

5 楼 achui_1980 2009-09-15  

学习了，一直对这个不是很理解

4 楼 ziyu_1 2009-07-24  

public void update(Observable o, Object arg) {   
        displayTemputer(((Heater) o).getTemperature());//这里不是很好   
    }

在调用通知的时候,
直接把变化的温度传过去,
这样在上面的代码就不用把o强制转换成Heater,arg就是传过来的温度了.
达到这两个对象解耦的作用

修改如下

public void boilWater() {   
        for (int i = 90; i < 100; i++) {   
            temperature = i;   
            this.setChanged();   
            this.notifyObservers(temperature);   
        }   
    }

public void update(Observable o, Object arg) {   
        displayTemputer(arg);//这里不是很好   
    }

3 楼 ziyu_1 2009-07-24  

报警器监视显示器,这个不太合理吧.报警器应该直接监视温度
显示器,报警器都是监视者,被监视的只有加热器(温度)

2 楼 xu_zh_h 2009-07-24  

如果把热水器换成温度测量器，再增加一个水，让水、显示器、报警器都是观察者。温度计是目标

1 楼 case0079 2009-02-26  

本来就不合适有大量Observer的.