java(23) - 观察者模式

标签：java

一.观察者模式：

    (1).观察者模式定义：定义了一种一对多的依赖关系，让多个观察者监听某个主体对象。当主题对象发生改变时，则会通知所有的观察者对象，让它们自动更新自己。

     (2).观察者模式的组成：

          a).具体主题角色：在具体主题角色内部发生变化时，给所有注册过的观察者发出通知。(通常使用一个类实现)

          b).抽象主题角色：把所有观察者对象的引用保存的在一个集合中，每个抽象主题角色都可以有任意个观察者，一般用抽象类或接口实现。

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

          d).具体观察者角色：实现抽象观察者角色所要求的更新接口。

二.实现自己的观察者模式：

1).抽象主题角色：

//被观察的，就是抽象主题角色
public interface Watched {
    
	//增加观察者
	public void addWatcher(Watcher watcher);
	//删除观察者
	public void removeWatcher(Watcher watcher);
	//通知观察者
	public void notifyWatchers(String str);

}

2).抽象观察者角色：

//观察的，就是抽象观察者角色
public interface Watcher {
	//更新自己
	public void update(String str);
	
}

3).具体主题角色：

//具体主题角色
public class ConcreteWatched implements Watched {
    //保存观察者
	private List<Watcher> list = new ArrayList<Watcher>();
	
	@Override
	public void addWatcher(Watcher watcher) {
		list.add(watcher);
	}

	@Override
	public void removeWatcher(Watcher watcher) {
		list.remove(watcher);
	}

	@Override
	public void notifyWatchers(String str) {
		//通知观察者
		for(Watcher watcher :list){
			
			watcher.update(str);
			
		}
	}

}

4).具体观察者角色：

//具体观察者角色
public class ConcreteWatcher implements Watcher{

	//实现接口的更新方法
	@Override
	public void update(String str) {

		System.out.println(str);
		
	}

}

5).测试：

public class index {

	public static void main(String[] args) {
		
		
		Watched w = new ConcreteWatched();
		
		Watcher r1 = new ConcreteWatcher();
		Watcher r2 = new ConcreteWatcher();
		Watcher r3 = new ConcreteWatcher();
		
		w.addWatcher(r1);
		w.addWatcher(r2);
		w.addWatcher(r3);
    
		w.notifyWatchers("哈哈");
	
	}
}

打印：

哈哈

哈哈

哈哈

三.JDK对观察者的内置支持：

      1).在jdk中提供了Observable类和Observer接口：

      Observable类用于创建可以观测到你的程序中其他部分的子类。当这种子类发生变化时通知其观察者。观察类必须实现了Observer接口的update()方法。

      2).必须调用的方法：

        一个被观察的对象发生改变时必须调用setChandeg()方法，在通知观察者时必须调用notifyObservers()方法。如果在通知观察者时未调用setChandeg()方法则就不会有任何的响应。

     3).notifyObservers()方法有两种形式：

          一个是带参数的一个是不带参数的。带参数的方法，其参数就是传给update()的第二个参数。

    简单实现：

//被观察者
class BeingWatched  extends Observable{
	
	public void  observerName(String str){
		//由false变为true，表示我可以发出通知了。
		this.setChanged();
		//通知观察者
		this.notifyObservers(str);
	}
	
}
//观察者对象一
class Watcher1 implements Observer{

	@Override
	public void update(Observable o, Object arg) {
		System.out.println(arg.toString()+"Watcher1");
		
	}
	
	
}
//观察者对象二
class Watcher2 implements Observer{

	@Override
	public void update(Observable o, Object arg) {
		System.out.println(arg.toString()+"Watcher2");
	}
	
	
}
public class ObservableTest {

	public static void main(String[] args) {
		
		
		BeingWatched  watched = new BeingWatched();
		
		Watcher1  w1 = new Watcher1();
		Watcher2  w2 = new Watcher2();
		
		watched.addObserver(w1);
		watched.addObserver(w2);
		
		watched.observerName("我是观察者：");
	}
	
}

打印：

我是观察者：Watcher2
我是观察者：Watcher1

四.观察者的适用：

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

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

java(23) - 观察者模式

标签：java

原文地址：http://blog.csdn.net/u010708662/article/details/44343861