“观察者模式总结”【这个是在“AWT事件总结”博客文章的基础上进行的总结】

这篇文章是在前面的“AWT事件总结”博客文章的基础上总结的，其实前面的讲到AWT事件就是一个典型的观察者模式使用场景（一个典型的应用示例），这样顺序的讲解目的是为了让我们能用AWT事件来深刻的理解观察者模式。

下面讲解观察者模式：

那么在上面事件的调用过程中，为什么监听器比如ActionListener实现类里面特定事件的方法会在事件发生的时候被调用呢？这里用到了一种模式，观察者模式。

观察者模式(Observer)：
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个猪蹄对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己。

观察者模式的组成：
1、抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和扇车观察者角色。一般用一个抽象类或接口来实现。
2、抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
3、具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
4、具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现。

所谓的注册就是将一个观察者的对象应用存放到了主题里面去了么(一般是集合)。我们的方法最后肯定是主题来执行的呀，一定不是平白无故的自己就去执行了呀。永远没有自动调用这一回事，自动调用只是一种表面现象，是你还没有明白底层是怎么实现的。

下面的几个类是一个简单的典型的观察者模式程序：

package com.shengshiyuan.observer;

/**
 * 抽象观察者角色
 * 类: Watcher <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 5, 2013 5:36:14 PM
 */
public interface Watcher {
	// 在得到主题的通知时更新自己
	public void udpate(String str);
}

package com.shengshiyuan.observer;

/**
 * 抽象主题角色
 * 类: Watched <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 5, 2013 5:34:56 PM
 */
public interface Watched {
	// 添加观察者
	public void addWatcher(Watcher watcher);

	// 移除观察者
	public void removeWatcher(Watcher watcher);

	// 通知观察者
	public void notifyWatchers(String str);
}

package com.shengshiyuan.observer;

/**
 * 具体观察者角色
 * 类: ConcreteWatcher <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 5, 2013 5:51:47 PM
 */
public class ConcreteWatcher implements Watcher {

	public void udpate(String str) {
		System.out.println(str);
	}

}

package com.shengshiyuan.observer;

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

/**
 * 具体主题角色
 * 类: ConcreteWatched <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 5, 2013 5:44:06 PM
 */
public class ConcreteWatched implements Watched {

	// 一个主题会有多个观察者，多个观察者会放到一个集合里面，起到维护的作用。这个集合用来承载观察我的哪些观察者
	private List<Watcher> list = new ArrayList<Watcher>();

	public void addWatcher(Watcher watcher) {
		list.add(watcher);
	}

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

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

package com.shengshiyuan.observer;

/**
 * 测试类
 * 类: Test <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 5, 2013 7:42:46 PM
 */
public class Test {
	public static void main(String[] args) {
		// 女为悦己者容（女孩有好多追求者）
		Watched girl = new ConcreteWatched();

		// 为其添加观察者
		Watcher watcher1 = new ConcreteWatcher();
		Watcher watcher2 = new ConcreteWatcher();
		Watcher watcher3 = new ConcreteWatcher();

		girl.addWatcher(watcher1);
		girl.addWatcher(watcher2);
		girl.addWatcher(watcher3);

		girl.notifyWatchers("开心，爽");

		// 女孩不喜欢第二个追求者，将他删除(移除观察者)
		girl.removeWatcher(watcher2);

		girl.notifyWatchers("爽！");
	}
}

观察者模式在Java语言中的地位极其重要。
JDK都认为观察者模式非常重要，所以它也内置了观察者模式的支持，而其他模式不会有这样的待遇。JDK为观察者模式提供了一种支持，为其提供了类提供了接口来支持它。

Observable类用于创建可以观测到你的程序中其他部分的子类【它是一个主题角色，它是一对多里面一的那一方，是有多个人去观测它】。当这种子类的对象发生变化时，观测类被通知。观测类必须实现定义了update()方法的Observer接口。当一个观测程序被通知到一个被观测对象的改变时，update()方法被调用。

Observable是我们的主题角色（我们继承这个类来创建我们自己的主题对象）。Observer是抽象的观察者，我们实现它来定义自己的具体观察者。

一定要重点查看Observable类的源码，一定要重点查看。仔细查看完之后Observable类的源码和我们最初自己实现的那个简单的观察者模式里面的ConcreteWatched 类代码特别相似，只是多了一个主题是否改变的Boolean变量和对它操纵的几个方法以及机制而已。


Observable(观测)：
注意notifyObservers()有两种形式：一种带有参数而另一种没有。当用参数调用notifyObservers()方法时，该对象被传给观测程序的update()方法作为其第二个参数。否则，将给update()方法传递一个null。可以使用第二个参数传递适合于你的应用程序的任何类型的对象。

为了观测一个可观测的对象，必须实现Observer接口。这个接口仅仅定义了如下所示的一个方法：
---void update(Observable observOb,Object arg)
---这里，observOb是被观测的对象，而arg是由notifyObservers(Object arg)方法传递的值。当被观测对象发生了改变，调用update()方法。


这里是一个说明可观测对象的例子。该程序创建了一个叫Watcher的类，该类实现了Observer接口。被监控的类叫做Being Watched，它继承了Observable。在Being Watched里，是counter()方法，该方法仅是从一个指定的值开始递减计数。每次计数改变时，notifyObservers()方法被调用，而当前的计数被作为参数传递给notifyObservers()方法。这导致了Watcher中的update()方法被调用，显示当前的计数值。在main()内，分别调用observing和observed的Watcher和Being Watched对象被创建。然后，observing被增加到对observed的观测程序列表。这意味着每次counter()调用notifyObservers()方法时，observing.update()方法将被调用。


一个被观测的对象必须服从下面两个简单规则。第一，如果它被改变了，它必须调用setChanged()方法。第二，当它准备通知观测程序它的改变时，它必须调用notifyObservers()方法。这导致了在观测对象中对update()方法的调用。注意---当对象在调用notifyObservers()方法之前，没有调用setChanged()方法，就不会有什么动作发生。在update()被调用之前，被观测对象必须调用setChanged()和notifyObservers()两种方法。

下面是针对观察者模式留的一个作业：
作业：
1)阅读Observable类的源代码，理解Observable类与Observer接口之间的调用关系。
2)编写一个程序，声明一个类，该类继承自Observable（因此该类是个主题角色），有一个int 类型的变量，初始值为10，编写一个for 循环，将该数字每次递减1，一直到0为止，每次变化时，都将该数字传递给它的观察者，观察者会打印出该数字；第二个观察者在该数字变为5之后开始打印该数字。

下面两个类是自己的作业完成情况（没有经过修改）：

package com.shengshiyuan.observer2;

import java.util.Observable;

/**
 * 主题角色
 * 类: RealObservable <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 6, 2013 6:02:32 PM
 */
public class RealObservable extends Observable {

	private static int a;

	/**
	 * 其实重写这个方法没有多大用处
	 * 方法: notifyObservers <br>
	 * 描述: TODO
	 * @param arg 
	 * @see java.util.Observable#notifyObservers(java.lang.Object)
	 */
	@Override
	public void notifyObservers(Object arg) {
		super.setChanged();// 告诉Observable自己的这个主题已经发生了改变(一个标志位)
		super.notifyObservers(arg);
	}

	/**
	 * 测试类
	 * 方法: main <br>
	 * 描述: TODO <br>
	 * 作者: 
	 * 时间: Nov 6, 2013 6:01:55 PM
	 * @param args
	 */
	public static void main(String[] args) {
		RealObserver observer1 = new RealObserver();
		RealObserver observer2 = new RealObserver();

		RealObservable observable = new RealObservable();
		observable.addObserver(observer1);

		for (a = 10; a >= 0; a--) {
			if (a == 5) {
				observable.addObserver(observer2);
			}
			observable.notifyObservers(a);
		}
	}
}

package com.shengshiyuan.observer2;

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

/**
 * 观察者
 * 类: RealObserver <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 6, 2013 6:03:12 PM
 */
public class RealObserver implements Observer {

	public void update(Observable o, Object arg) {
		System.out.println(arg);
	}

}

下面的代码是老师最后最后针对作业完成的标准代码，他只用了一个类：

package com.shengshiyuan.observer2;

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

/**
 * 主题对象
 * 类: BeingWatched <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 6, 2013 5:14:01 PM
 */
class BeingWatched extends Observable {
	void counter(int number) {
		// number每递减一就通知一次下面的观察者
		for (; number >= 0; number--) {
			// 调用此方法修改标志位
			this.setChanged();
			// 通知观察者
			this.notifyObservers(number);
		}
	}
}

/**
 * 观察者对象
 * 类: Watcher1 <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 6, 2013 5:13:55 PM
 */
class Watcher1 implements Observer {
	public void update(Observable o, Object arg) {
		System.out.println("Watcher1's count is" + arg);
	}
}

/**
 * 第二个观察者对象
 * 类: Watcher2 <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 6, 2013 5:15:58 PM
 */
class Watcher2 implements Observer {
	public void update(Observable o, Object arg) {
		if (((Integer) arg).intValue() <= 5) {
			System.out.println("Watcher2's count is" + arg);
		}
	}
}

/**
 * 测试类
 * 类: TwoObservers <br>
 * 描述: TODO <br>
 * 作者: 
 * 时间: Nov 6, 2013 5:17:53 PM
 */
public class TwoObservers {
	public static void main(String[] args) {
		BeingWatched watched = new BeingWatched();

		Watcher1 watcher1 = new Watcher1();
		Watcher2 watcher2 = new Watcher2();

		watched.addObserver(watcher1);
		watched.addObserver(watcher2);

		watched.counter(10);
	}
}