设计模式——观察者模式

Java 提供了 Observer 模式的默认实现，下面我们就看一下 Java 对 观察者模式的支持。

Java 对 观察者模式的支持 主要体现在 Observable 类和 Observer 接口。

(1) Observable 类代表 被观察者 （java.util.Observable ）

主要方法有：

void setChanged() ： 设置被观察者的状态已经被改变
void addObserver(Observer observer) ： 添加观察者
int countObservers() ： 返回所有观察者的数目
void deleteObserver(Observer observer) ：删除指定观察者
void deleteObservers() ： 删除所有观察者
boolean hasChanged() ： 被观察者的状态是否被改变，如果是则返回true，否则返回false
void notifyObservers() ： 通知所有观察者（没有参数）

void notifyObservers(Object arg) ： 通知所有观察者（带参数，参数一般设定为被改变的属性）
void clearChanged() ：清除被观察者状态的改变（即调用 hasChanged() 时会返回 false）

(2) Observer 接口代表 观察者 （java.util.Observer ）

它只有一个抽象方法需要被具体的观察者类实现（很重要 ）：

void update(Observable observable, Object arg) ：当 被观察者 调用 notifyObservers(*) 方法

时，会根据被观察者的 hasChanged() 方法 来判断 它的状态是否被改变， 如果被观察者的状态被改变了，则

会调用 观察者 的 update 方法，参数 observable 为 被观察者对象， arg 为调用 notifyObservers( Object arg ) 时传入的参数 arg ，如果调用的是 notifyObservers() 方法， 则 arg 为 null（ 注意 ：应该把这个参数 arg 设定为 被观察者的 被改变的属性）。

 

简单的例子：

 

public class MyObservable extends Observable {
	String info = "something happened !! ";

	public MyObservable () {
		// add observer 1
		this.addObserver( new Observer() {
			public void update(Observable o, Object arg) {
				System.out.println("Observer 2 updated for <"+info+">");
				System.out.println("Observer 1 updated!");
				System.out.println("Observable is <" + o + ">");
				System.out.println("Object is <" + arg + ">");
			}
		});

		// add observer 2
		this.addObserver(new Observer() {
			// 自己实现一个 Observer
			public void update(Observable o, Object arg) {
				System.out.println("Observer 2 updated!");
				System.out.println("Observable is <" + o + ">");
				System.out.println("Object is <" + arg + ">");
			}
		}); 
	} 

	public static void main(String[] args) { 
		MyObservable obs = new MyObservable(); 

		obs.setChanged(); 
		obs.notifyObservers(); 
		System.out.println("=======================================");

		obs.addObserver(new Observer() {
			// 自己实现一个 Observer   
			public void update(Observable o, Object arg) {
				System.out.println("Observer 3 updated");
				System.out.println("Observable is <" + o + ">");
				System.out.println("Object is <" + arg + ">");
			}  
		}); 

		obs.setChanged();
		obs.notifyObservers(obs.info);
	} 
}

 

 

运行结果：

 

写道

Observer 2 updated!
Observable is <P1.MyObservable@10b30a7>
Object is <null>
Observer 2 updated for <something happened !! >
Observer 1 updated!
Observable is <P1.MyObservable@10b30a7>
Object is <null>
=======================================
Observer 3 updated
Observable is <P1.MyObservable@10b30a7>
Object is <something happened !! >
Observer 2 updated!
Observable is <P1.MyObservable@10b30a7>
Object is <something happened !! >
Observer 2 updated for <something happened !! >
Observer 1 updated!
Observable is <P1.MyObservable@10b30a7>
Object is <something happened !! >

 

 

开始是没有参数的notify，后面是有参数的notify。

 

该模式适用的场景：这里有两个角色，一个是观察者，一个是被观察者，观察者是一个抽象的类，也就是要是继承这个类，具体类就不能够实现别的类了。观察者也是比较的简单只要实现一个update的方法，这个方法得到两个参数，第一参数是被观察者，第二个参数是被观察者传替的一个参数，notifyObservers(obs.info);，这个方法传入的。这样我们就可以想一下了，也就是，一个观察者，可以观察多个【被观察者】，然后观察者可以再update中区别是不同的【被观察者】发出的notify，同时也可以查看【被观察者】所传替的状态，来判断自己所要执行的操作了。【被观察者】这个角色是非常重要的，【被观察者】其实是一个管理者的角色，它可以增加观察者，删除观察者，通知事件的发生，通知事件的状态【通过参数】。

 

如打麻将例子：棋牌室是管理者，也就是【被观察者】，这个棋牌室有一些固定的会员，也就是观察者，在棋牌室有注册，也就是在【被观察者】中添加为了观察者，棋牌室到了下午，常常的麻将时间了，notifyObservers（），通知所有的会员，也就是打麻将的时间到了，有时间就来打麻将吧。a、b、c、d、e、f都是这里的会员，都收到了这个通知，a、b、c增好今天有时间就立刻去了，打麻将要4个人才好打，去早了要等，d比较的滑头，收到一开始的通知没有去，因为它知道棋牌室在每次去人之后，还会发出通知notifyObservers（3），这时候通知是有参数的，也就是说已经来了3个人，d收到这个通知，立刻就去棋牌室打牌了。a、b、c也会收到这样的通知，但这个时候他们已经到棋牌室了，就不在响应棋牌室的事情了，也可以理解为，我已经响应了。e、f在家带孩子，棋牌室的通知，知道了，也不响应。

 

多【被观察者】，引申上面的例子：a、b、c、d收到棋牌室的通知，打牌去，但是他们还是会相应别的事件的，如c，家里是有小孩的，老婆周末在家看着小孩，他出来打牌了，老婆突然接到妈妈的电话，要晚上过来吃饭，于是乎，立刻通知c，回来的带孩子，自己要去买菜，于是，c回去了。这个c观察【棋牌室】也观察【老婆的指示】

 

【被观察者】链，引申上面的例子：【被观察者】可以同时又是别的观察者，如上面棋牌室，是麻将们的【被观察者】，棋牌室这种的行为啊，有时候，警察要去看看，有没有巨赌，有赌娱乐就算了，不管怎样，棋牌室还是比较的怕警察的检查，于是这条街上面的棋牌室A、B、C就说，我一人出50元，给街头卖报纸的小赵，赵看到警察到街头了，赵就电话通知A、B、C，警察来了。A、B、C赶快让赌徒们收起大钞，1毛2毛娱乐

 

注意：

1，【被观察者】是线程安全的。

2，