java观察者模式介绍
概念
Observer模式定义对象间的一对多的依赖关系,当一个对象（被观察者）的状态发生改变时, 所有依赖于它的对象（观察者）都得到通知并被自动更新。JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。从名字上可以清楚的看出两者在Observer 设计模式中分别扮演的角色：Observer是观察者角色，Observable是被观察目标(subject)角色。
相关类介绍
1.Obervable类
此类表示模型视图范例中的 observable 对象，继承它的类表示应用程序想要观察的对象。一个 observable 对象可以有一个或多个观察者。观察者是实现Observer接口的任意对象。一个 observable 实例改变后，调用 Observable 的 notifyObservers 方法的应用程序会通过调用观察者的 update 方法来通知观察者该实例发生了改变。
| 方法摘要 | |
| void | addObserver( o) 如果观察者与集合中已有的观察者不同，则向对象的观察者集中添加此观察者。未指定向多个观察者发送通知的顺序。 |
| protected void | clearChanged() 指示对象不再改变，或者它已对其所有的观察者通知了最近的改变，所以 hasChanged 方法将返回 false。notifyObservers 方法自动调用此方法。 |
| int | countObservers() 返回 Observable 对象的观察者数目。 |
| void | deleteObserver( o) 从对象的观察者集合中删除某个观察者。向此方法传递 null无效。 |
| void | deleteObservers() 清除观察者列表，使此对象不再有任何观察者。 |
| boolean | hasChanged() 测试对象是否改变。当且仅当在此对象上最近调用了 setChanged 方法时才返回 true；否则返回 false。 |
| void | notifyObservers() 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。每个观察者都有其 update 方法，其调用参数有两个：observable 对象和 null。换句话说，此方法等效于： notifyObservers(null) |
| void | notifyObservers( arg) 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。每个观察者都有其 update 方法，其调用参数有两个：observable 对象和 arg 参数。 arg 可以是任意对象 |
| protected void | setChanged() 标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。 |
关于发送通知的顺序
Observable 类中所提供的默认实现将按照其注册的重要性顺序来通知 Observers，但是子类可能改变此顺序，从而使用非固定顺序在单独的线程上发送通知，或者也可能保证其子类遵从其所选择的顺序。
注意：此通知机制与线程无关，并且与 Object 类的 wait 和 notify 机制完全独立。
新创建一个 observable 对象时，其观察者集是空的。当且仅当 equals 方法为两个观察者返回 true 时，才认为它们是相同的。
2.Oberver接口
这是个接口类，这个接口只有一个为实现的抽象方法update。实现该接口的对象成为观察者，该对象要实现update方法。注册了该对象（观察者）的对象（观察者）实例条用notifiyObservers方法后，观察者会自动执行update方法。
| 方法摘要 | |
| void | update( o, arg) 只要改变了 observable 对象就调用此方法。o - observable 对象。 arg - notifyObservers 方法的参数。 |
实例
该实例模拟了烧水的过程，涉及三个对象，Heater(热水器),Display（显示器）,Alarm(报警器).
模拟过程：为了便于运行，水的初始化温度为90，沸点为95，显示器依据热水器显示温度，显示器显示温度为95时，报警器开始报警。明显可以看出Heater是subject ,Display 是它的 Obsrver，同时Display亦是subject，因为它要被报警器观察，所以Alarm是Display的Observer.
Heater.java类
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 < 110; i++) {
temperature = i;
this.setChanged();
this.notifyObservers();
}
}
}
Display.java类
public class Display extends Observable implements Observer {
private String status = "未开";
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
@Override
public void update(Observable o, Object arg) {
this.displayTemperature(((Heater) o).getTemperature());
}
private void displayTemperature(int temperature) {
if (temperature > 100) {
this.setStatus("沸腾");
this.setChanged();
this.notifyObservers(temperature);
}
System.out.println("状态： " + status + " 现在温度： " + temperature);
}
}
Alarm.java类
public class Alarm implements Observer {
@Override
public void update(Observable arg0, Object arg1) {
this.makeAlarm((Integer) arg1);
}
private void makeAlarm(int temperature) {
System.out.println("嘀嘀嘀。。。水已经烧开了");
// System.out.println("现在水温是： " + temperature);
}
}
TestMain.java测试入口类
public class TestMain {
public static void main(String[] args) {
Heater heater = new Heater();
Display display = new Display();
Alarm alarm = new Alarm();
heater.addObserver(display);
display.addObserver(alarm);
heater.boilWater();
}
}
优点
- 支持松耦合和减少依赖性。客户端不再依赖于观察器，因为通过使用主体和 Observer 接口对客户端进行了隔离。许多框架具有此优点，在这些框架中的应用程序组件可以注册为当（低级）框架事件发生时得到通知。结果，框架将调用应用程序组件，但不会依赖于它。
- 观察器数目可变。观察器可以在运行时附加和分离，因为主体对于观察器数目没有任何假定。此功能在这样的情况下是很有用的：观察器数在设计时是未知的。例如，如果用户在应用程序中打开的每个窗口都需要一个观察器。
缺点
-
- 性能降低。在许多实现中，观察器的 update() 方法可能与主体在同一线程中执行。如果观察器列表很长，则执行 Notify() 方法可能需要很长时间。抽取对象依赖性并不意味着添加观察器对应用程序没有任何影响。
- 内存泄漏。在 Observer 中使用的回调机制（当对象注册为以后调用时）会产生一个常见的错误，从而导致内存泄漏，甚至是在托管的 C# 代码中。假定观察器超出作用范围，但忘记取消对主体的订阅，那么主体仍然保留对观察器的引用。此引用防止垃圾收集在主体对象也被破坏之前重新分配与观察器关联的内存。如果观察器的生存期比主体的生存期短得多（通常是这种情况），则会导致严重的内存泄漏。
- 隐藏的依赖项。观察器的使用将显式依赖性（通过方法调用）转变为隐式依赖性（通过观察器）。如果在整个应用程序中广泛地使用观察器，则开发人员几乎不可能通过查看源代码来了解所发生的事情。这样，就使得了解代码更改的含意非常困难。此问题随传播级别急剧增大（例如，充当 Subject 的观察器）。因此，应该仅在少数定义良好的交互（如 Model-View-Controller 模式中模型和视图之间的交互）中使用观察器。最好不要在域对象之间使用观察器。
- 测试/调试困难。尽管松耦合是一项重大的体系结构功能，但是它可以使开发更困难。将两个对象去耦的情况越多，在查看源代码或类的关系图时了解它们之间的依赖性就越难因此，仅当可以安全地忽略两个对象之间的关联时才应该将它们松耦合（例如，如果观察器没有副作用）。
Java观察者模式 java.util.Observable 与 java.util.Observer 的理解
Java观察者模式 java.util.Observable 与 java.util.Observer 的理解
Part I
JDK1.2后，Java提供了对观察者模式的支持接口和实现类。
其中接口 java.util.Observer 用来指定观察者，观察者必须实现 void update(Observable o, Object arg) 方法。
而 java.util.Observable 用来指定观察物（被观察者、可被观察的），并且提供了一系列的方法。读者可以很轻易的使用这个接口和实现类来实现观察者模式。
Part II
java.util.Observer 只有一个简单的方法 void update(Observable o, Object arg)
其中，参数 Observable o 用于指定触发 update 方法的对象， Object arg 用于指定触发 update 方法时候的附加参数。
如果有桌面应用开发的读者应该很了解，这跟事件处理机制是完全一样的，其中 Observable o 可被看作事件源。 Object arg 可被看作消息。
Part III
说了那么多，我们还是动手写个例子吧。这里我们以读者订阅杂志为例子。
package com.gzmu.observer.observable;
import java.util.Observable;publicclass Publisher extends Observable { private String magazineName;public String getMagazineName() { return magazineName;}publicvoid publish(String magazineName) { this.magazineName = magazineName;setChanged();notifyObservers(this);}}package com.gzmu.observer.observer;import java.util.Observable;import java.util.Observer;import com.gzmu.observer.observable.Publisher;publicclass Reader implements Observer { @Overridepublicvoid update(Observable o, Object arg) { Publisher p = (Publisher) o;System.out.println("我要订阅" + p.getMagazineName());}}package com.gzmu.observer.test;import org.junit.Test;import com.gzmu.observer.observable.Publisher;publicclass TestCase { @Testpublicvoid register() { Publisher publisher = new Publisher();publisher.publish("Kent.Kuan的技术空间");}}这里很清楚的看到，当出版社出版杂志的时候，会主动的告知读者，读者就会订阅杂志，这也是一种主动推送的模式。
Part IV
这里大家会发现，调用 notifyObservers() 的时候，为什么传进当前对象 this 呢？而这个 this， 我们在读者那也没用到啊。这个问题曾经也让我觉得很苦恼，之前我也不清楚为什么观察者要拿到被观察对象的引用，但是，我们看看下面这个例子。
首先我们引用一个新的类：
package com.gzmu.observer.observable;
import java.util.Observable;publicclass TVStation extends Observable { private String programmeName;publicvoid play(String programmeName) { this.programmeName = programmeName;setChanged();notifyObservers(this);}public String getProgrammeName() { return programmeName;}}然后修改Reader和TestCase：
package com.gzmu.observer.observer;
import java.util.Observable;import java.util.Observer;import com.gzmu.observer.observable.Publisher;import com.gzmu.observer.observable.TVStation;publicclass Reader implements Observer { @Overridepublicvoid update(Observable o, Object arg) { if (o instanceof Publisher) { Publisher p = (Publisher) o;System.out.println("我要订阅" + p.getMagazineName());}if (o instanceof TVStation) { TVStation t = (TVStation) o;System.out.println("我要收看" + t.getProgrammeName());}}}package com.gzmu.observer.test;import org.junit.Test;import com.gzmu.observer.observable.Publisher;import com.gzmu.observer.observable.TVStation;import com.gzmu.observer.observer.Reader;publicclass TestCase { @Testpublicvoid register() { Reader reader = new Reader();Publisher publisher = new Publisher();publisher.addObserver(reader);TVStation tvStation = new TVStation();tvStation.addObserver(reader);publisher.publish("Kent.Kwan的技术空间");tvStation.play("色戒");}}最后我们可以看到，同一个观察者其实是可以注册到不同的被观察者上面的，而传过来的 Oberverable o 其实可以用来检验到底是谁发过来的消息。
除此以外，我们还可以在接受到消息之后，进行撤销观察的工作。
package com.gzmu.observer.observer;
import java.util.Observable;import java.util.Observer;import com.gzmu.observer.observable.Publisher;import com.gzmu.observer.observable.TVStation;publicclass Reader implements Observer { @Overridepublicvoid update(Observable o, Object arg) { if (o instanceof Publisher) { Publisher p = (Publisher) o;p.deleteObserver(this);System.out.println("我要订阅" + p.getMagazineName());}if (o instanceof TVStation) { TVStation t = (TVStation) o;System.out.println("我要收看" + t.getProgrammeName());}}}通过 deleteObserver() 方法就可以撤销观察出版社对象。
Java 观察者模式的浅析
在观察者模式里有如下的角色：
. 抽象主题（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(); } 
} 代码清单6、java.util.Observer接口的源代码。 这个Observable类代表一个被观察者对象。一个被观察者对象可以有数个观察者对象，一个观察者可以是一个实现Observer接口的对象。在被观察者对象发生变化时，它会调用Observable的notifyObservers方法，此方法调用所有的具体观察者的update()方法，从而使所有的观察者都被通知更新自己。见下面的类图：
图8、使用Java语言提供的对观察者模式的支持。 发通知的次序在这里没有指明。Observerable类所提供的缺省实现会按照Observers对象被登记的次序通知它们，但是Observerable类的子类可以改掉这一次序。子类并可以在单独的线程里通知观察者对象；或者在一个公用的线程里按照次序执行。 当一个可观察者对象刚刚创立时，它的观察者集合是空的。两个观察者对象在它们的equals()方法返回true时，被认为是两个相等的对象。 怎样使用Java对观察者模式的支持 为了说明怎样使用Java所提供的对观察者模式的支持，本节给出一个非常简单的例子。在这个例子里，被观察对象叫做Watched，也就是被监视者；而观察者对象叫做Watcher。Watched对象继承自java.util.Obsevable类；而Watcher对象实现了java.util.Observer接口。另外有一个对象Tester，扮演客户端的角色。 这个简单的系统的结构如下图所示。 图9、一个使用Observer接口和Observable类的例子。 在客户端改变Watched对象的内部状态时，Watched就会通知Watcher采取必要的行动。package com.javapatterns.observer.watching;import java.util.Observer;public class Tester{ static private Watched watched;static private Observer watcher;public static void main(String[] args){ watched = new Watched();watcher = new Watcher(watched);watched.changeData("In C, we create bugs.");watched.changeData("In Java, we inherit bugs.");watched.changeData("In Java, we inherit bugs.");watched.changeData("In Visual Basic, we visualize bugs."); }} 代码清单7、Tester类的源代码。 package com.javapatterns.observer.watching;import java.util.Observable;public class Watched extends Observable{ private String data = "";public String retrieveData(){ return data;}public void changeData(String data){ if ( !this.data.equals( data) ){ this.data = data;setChanged();}notifyObservers();}} 代码清单8、Watched类的源代码。 package com.javapatterns.observer.watching;import java.util.Observable;import java.util.Observer;public class Watcher implements Observer{ public Watcher(Watched w){ w.addObserver(this);}public void update( Observable ob, Object arg){ System.out.println("Data has been changed to: '" + ((Watched)ob).retrieveData() + "'");}} 代码清单9、Watcher类的源代码。 可以看出，虽然客户端将Watched对象的内部状态赋值了四次，但是值的改变只有三次：watched.changeData("In C, we create bugs.");watched.changeData("In Java, we inherit bugs.");watched.changeData("In Java, we inherit bugs.");watched.changeData("In Visual Basic, we visualize bugs."); 代码清单10、被观察者的内部状态发生了改变。 对应地，Watcher对象汇报了三次改变，下面就是运行时间程序打印出的信息：Data has been changed to: 'In C, we create bugs.'Data has been changed to: 'In Java, we inherit bugs.'Data has been changed to: 'In Visual Basic, we visualize bugs.' 代码清单11、运行的结果。 菩萨的守瓶龟 想当年齐天大圣为解救师傅唐僧，前往南海普陀山请菩萨降伏妖怪红孩儿：“菩萨听说...恨了一声，将手中宝珠净瓶往海心里扑的一掼...只见那海当中，翻波跳浪，钻出个瓶来，原来是一个怪物驮着出来...要知此怪名和姓，兴风作浪恶乌龟。” 使用面向对象的语言描述，乌龟便是一个观察者对象，它观察的主题是菩萨。一旦菩萨将净瓶掼到海里，就象征着菩萨作为主题调用了notifyObservers()方法。在西游记中，观察者对象有两个，一个是乌龟，另一个是悟空。悟空的反应在这里暂时不考虑，而乌龟的反应便是将瓶子驮回海岸。 图10、菩萨和菩萨的守瓶乌龟。 菩萨作为被观察者对象，继承自Observable类；而守瓶乌龟作为观察者，继承自Observer接口；这个模拟系统的实现可以采用Java对观察者模式的支持达成。
Java中的DEM事件机制
AWT中的DEM机制 责任链模式一章中曾谈到，AWT1.0的事件处理的模型是基于责任链的。这种模型不适用于复杂的系统，因此在AWT1.1版本及以后的各个版本中，事件处理模型均为基于观察者模式的委派事件模型（Delegation Event Model或DEM）。 在DEM模型里面，主题（Subject）角色负责发布（publish）事件，而观察者角色向特定的主题订阅（subscribe）它所感兴趣的事件。当一个具体主题产生一个事件时，它就会通知所有感兴趣的订阅者。 使用这种发布-订阅机制的基本设计目标，是提供一种将发布者与订阅者松散地耦合在一起的联系形式，以及一种能够动态地登记、取消向一个发布者的订阅请求的办法。显然，实现这一构思的技巧，是设计抽象接口，并把抽象层和具体层分开。这在观察者模式里可以清楚地看到。 使用DEM的用词，发布者叫做事件源（event source），而订阅者叫做事件聆听者（event listener）。在Java里面，事件由类代表，事件的发布是通过同步地调用成员方法做到的。 Servlet技术中的的DEM机制 AWT中所使用的DEM事件模型实际上被应用到了所有的Java事件机制上。Servlet技术中的事件处理机制同样也是使用的DEM模型。 SAX2技术中的DEM机制 DEM事件模型也被应用到了SAX2的事件处理机制上。 观察者模式的效果 观察者模式的效果有以下的优点： 第一、观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。 由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。 第二、观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知， 观察者模式有下面的缺点： 第一、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 第二、如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。 第三、如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。 第四、虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。 观察者模式与其它模式的关系 观察者模式使用了备忘录模式(Memento Pattern)暂时将观察者对象存储在被观察者对象里面。 问答题 第一题、我和妹妹跟妈妈说：“妈妈，我和妹妹在院子里玩；饭做好了叫我们一声。”请问这是什么模式？能否给出类图说明？ 问答题答案 第一题答案、这是观察者模式。我和妹妹让妈妈告诉我们饭做好了，这样我们就可以来吃饭了。换用较为技术化的语言来说，当系统的主题（饭）发生变化时，就告诉系统的其它部份（观察者们，也就是妈妈、我和妹妹），使其可以调整内部状态（有开始吃饭的准备），并采取相应的行动（吃饭）。 系统的类图说明如下。图11、系统的类图。