简单地说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的那些观察者对象，使这些观察者对象能够自动更新。
　　观察者模式的结构
　　观察者（observer）模式是对象的行为型模式，又叫做发表-订阅（publish/subscribe）模式、模型-视图（model/view）模式、源-收听者（source/listener）模式或从属者（dependents）模式。
　　本模式的类图结构如下：
　　　

　　图1、观察者模式的静态结构可从类图中看清楚。　
　　在观察者模式里有如下的角色：
　　. 抽象主题（subject）角色：主题角色把所有的观察者对象的引用保存在一个列表里；每个主题都可以有任何数量的观察者。主题提供一个接口可以加上或撤销观察者对象；主题角色又叫做抽象被观察者(observable)角色；
　　　
　　图2、抽象主题角色，有时又叫做抽象被观察者角色，可以用一个抽象类或者一个接口实现；在具体的情况下也不排除使用具体类实现。　
　　. 抽象观察者（observer）角色：为所有的具体观察者定义一个接口，在得到通知时更新自己；
　　　
　　图3、抽象观察者角色，可以用一个抽象类或者一个接口实现；在具体的情况下也不排除使用具体类实现。　
　　. 具体主题（concretesubject）角色：保存对具体观察者对象有用的内部状态；在这种内部状态改变时给其观察者发出一个通知；具体主题角色又叫作具体被观察者角色；
　　　
　　图4、具体主题角色，通常用一个具体子类实现。　
　　．具体观察者（concreteobserver）角色：保存一个指向具体主题对象的引用；和一个与主题的状态相符的状态。具体观察者角色实现抽象观察者角色所要求的更新自己的接口，以便使本身的状态与主题的状态自恰。
　　　
　　图5、具体观察者角色，通常用一个具体子类实现。　
　　下面给出一个示意性实现的java代码。首先在这个示意性的实现里，用一个java接口实现抽象主题角色，这就是下面的subject接口：
　　public interface subject
　　{
　　public void attach(observer observer);
　　public void detach(observer observer);
　　void notifyobservers();
　　}
　　代码清单1、subject接口的源代码。
　　这个抽象主题接口规定出三个子类必须实现的操作，即 attach() 用来增加一个观察者对象；detach() 用来删除一个观察者对象；和notifyobservers() 用来通知各个观察者刷新它们自己。抽象主题角色实际上要求子类保持一个以所有的观察者对象为元素的列表。
　　具体主题则是实现了抽象主题subject接口的一个具体类，它给出了以上的三个操作的具体实现。从下面的源代码可以看出，这里给出的java实现使用了一个java向量来保存所有的观察者对象，而 attach() 和 detach() 操作则是对此向量的元素增减操作。
　　import java.util.vector;
　　import java.util.enumeration;
　　public class concretesubject implements subject
　　public void attach(observer observer)
　　{
　　observersvector.addelement(observer);
　　}
　　public void detach(observer observer)
　　{
　　observersvector.removeelement(observer);
　　}
　　public void notifyobservers()
　　{
　　enumeration enumeration = observers();
　　while (enumeration.hasmoreelements())
　　{
　　((observer)enumeration.nextelement()).update();
　　}
　　}
　　public enumeration observers()
　　{
　　return (（vector) observersvector.clone()).elements();
　　}
　　private vector observersvector = new java.util.vector();
　　}
　　代码清单2、concretesubject类的源代码。
　　抽象观察者角色的实现实际上是最为简单的一个，它是一个java接口，只声明了一个方法，即update()。这个方法被子类实现后，一被调用便刷新自己。
　　public interface observer
　　{
　　void update();
　　}
　　代码清单3、observer接口的源代码。
　　具体观察者角色的实现其实只涉及update()方法的实现。这个方法怎么实现与应用密切相关，因此本类只给出一个框架。
　　public class concreteobserver implements observer
　　{
　　public void update()
　　{
　　// write your code here
　　}
　　}
　　代码清单4、concreteobserver类的源代码。
　　虽然观察者模式的实现方法可以有设计师自己确定，但是因为从awt1.1开始视窗系统的事件模型采用观察者模式，因此观察者模式在java语言里的地位较为重要。正因为这个原因，java语言给出了它自己对观察者模式的支持。因此，本文建议读者在自己的系统中应用观察者模式时，不妨利用java语言所提供的支持。
　　java语言提供的对观察者模式的支持
　　在java语言的java.util库里面，提供了一个observable类以及一个observer接口，构成java语言对观察者模式的支持。
　　observer接口
　　这个接口只定义了一个方法，update()。当被观察者对象的状态发生变化时，这个方法就会被调用。这个方法的实现应当调用每一个被观察者对象的notifyobservers()方法，从而通知所有的观察对象。
　　　
　　图6、java.util提供的observer接口的类图。　
　　package java.util;
　　public interface observer
　　{
　　/**
　　* 当被观察的对象发生变化时，这个方法会被调用。
　　*/
　　void update(observable o, object arg);
　　}
　　代码清单5、java.util.observer接口的源代码。
　　observable类
　　被观察者类都是java.util.observable类的子类。java.util.observable提供公开的方法支持观察者对象，这些方法中有两个对observable的子类非常重要：一个是setchanged()，另一个是notifyobservers()。第一个方法setchanged()被调用之后会设置一个内部标记变量，代表被观察者对象的状态发生了变化。第二个是notifyobservers()，这个方法被调用时，会调用所有登记过的观察者对象的update()方法，使这些观察者对象可以更新自己。
　　java.util.observable类还有其它的一些重要的方法。比如，观察者对象可以调用java.util.observable类的addobserver()方法，将对象一个一个加入到一个列表上。当有变化时，这个列表可以告诉notifyobservers()方法那些观察者对象需要通知。由于这个列表是私有的，因此java.util.observable的子对象并不知道观察者对象一直在观察着它们。
　　　
　　图7、java语言提供的被观察者的类图。　
　　被观察者类observable的源代码：
　　package java.util;
　　public class observable
　　{
　　private boolean changed = false;
　　private vector obs;
　　/** 用0个观察者构造一个被观察者。**/
　　
　　public observable()
　　{
　　obs = new vector();
　　}
　　/**
　　* 将一个观察者加到观察者列表上面。
　　*/
　　public synchronized void addobserver(observer o)
　　{
　　if (!obs.contains(o))
　　{
　　obs.addelement(o);
　　}
　　}
　　/**
　　* 将一个观察者对象从观察者列表上删除。
　　*/
　　public synchronized void deleteobserver(observer o)
　　{
　　obs.removeelement(o);
　　}
　　/**
　　* 相当于 notifyobservers(null)
　　*/
　　public void notifyobservers()
　　{
　　notifyobservers(null);
　　}
　　/**
　　* 如果本对象有变化（那时haschanged 方法会返回true）
　　* 调用本方法通知所有登记在案的观察者，即调用它们的update()方法，
　　* 传入this和arg作为参量。
　　*/
　　public void notifyobservers(object arg)
　　{
　　/**
　　* 临时存放当前的观察者的状态。参见备忘录模式。
　　*/
　　object[] arrlocal;
　　synchronized (this)
　　{
　　if (!changed) return;
　　arrlocal = obs.toarray();
　　clearchanged();
　　}
　　for (int i = arrlocal.length-1; i>=0; i--)
　　((observer)arrlocal[i]).update(this, arg);
　　}
　　/**
　　* 将观察者列表清空
　　*/
　　public synchronized void deleteobservers()
　　{
　　obs.removeallelements();
　　}
　　/**
　　* 将“已变化”设为true
　　*/
　　protected synchronized void setchanged()
　　{
　　changed = true;
　　}
　　/**
　　* 将“已变化”重置为false
　　*/
　　protected synchronized void clearchanged()
　　{
　　changed = false;
　　}
　　/**
　　* 探测本对象是否已变化
　　*/
　　public synchronized boolean haschanged()
　　{
　　return changed;
　　}
　　/**
　　* 返还被观察对象（即此对象）的观察者总数。
　　*/
　　public synchronized int countobservers()
　　{
　　return obs.size();
　　}
　　}
　　代码清单