这篇文章是在前面的“AWT事件总结”博客文章的基础上总结的,其实前面的讲到AWT事件就是一个典型的观察者模式使用场景(一个典型的应用示例),这样顺序的讲解目的是为了让我们能用AWT事件来深刻的理解观察者模式。
下面讲解观察者模式:
那么在上面事件的调用过程中,为什么监听器比如ActionListener实现类里面特定事件的方法会在事件发生的时候被调用呢?这里用到了一种模式,[color=red]观察者模式[/color]。
[color=red]观察者模式(Observer)[/color]:
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个猪蹄对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,让他们能够自动更新自己。
观察者模式的组成:
1、[color=red]抽象主题角色[/color]:把所有对观察者对象的引用保存在一个集合中,每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口,可以增加和扇车观察者角色。一般用一个抽象类或接口来实现。
2、[color=red]抽象观察者角色[/color]:为所有具体的观察者定义一个接口,在得到主题的通知时更新自己。
3、[color=red]具体主题角色[/color]:在具体主题内部状态改变时,给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
4、[color=red]具体观察者角色[/color]:该角色实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态相协调。如果需要,具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现。
所谓的注册就是将一个观察者的对象应用存放到了主题里面去了么(一般是集合)。我们的方法最后肯定是主题来执行的呀,一定不是平白无故的自己就去执行了呀。永远没有自动调用这一回事,自动调用只是一种表面现象,是你还没有明白底层是怎么实现的。
下面的几个类是一个简单的典型的观察者模式程序:
观察者模式在Java语言中的地位极其重要。
JDK都认为观察者模式非常重要,所以它也内置了观察者模式的支持,而其他模式不会有这样的待遇。JDK为观察者模式提供了一种支持,为其提供了类提供了接口来支持它。
[color=red]Observable[/color]类用于创建可以观测到你的程序中其他部分的子类【它是一个主题角色,它是一对多里面一的那一方,是有多个人去观测它】。当这种子类的对象发生变化时,观测类被通知。观测类必须实现定义了update()方法的[color=red]Observer接口[/color]。当一个观测程序被通知到一个被观测对象的改变时,update()方法被调用。
[color=red]Observable[/color]是我们的主题角色(我们继承这个类来创建我们自己的主题对象)。[color=red]Observer[/color]是抽象的观察者,我们实现它来定义自己的具体观察者。
[color=red]一定要重点查看Observable类的源码,一定要重点查看。仔细查看完之后Observable类的源码和我们最初自己实现的那个简单的观察者模式里面的ConcreteWatched 类代码特别相似,只是多了一个主题是否改变的Boolean变量和对它操纵的几个方法以及机制而已[/color]。
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()方法。[color=red]这导致了在观测对象中对update()方法的调用。注意---当对象在调用notifyObservers()方法之前,没有调用setChanged()方法,就不会有什么动作发生[/color]。[color=blue]在update()被调用之前,被观测对象必须调用setChanged()和notifyObservers()两种方法[/color]。
下面是针对观察者模式留的一个作业:
作业:
1)阅读Observable类的源代码,理解Observable类与Observer接口之间的调用关系。
2)编写一个程序,声明一个类,该类继承自Observable(因此该类是个主题角色),有一个int 类型的变量,初始值为10,编写一个for 循环,将该数字每次递减1,一直到0为止,每次变化时,都将该数字传递给它的观察者,观察者会打印出该数字;第二个观察者在该数字变为5之后开始打印该数字。
下面两个类是自己的作业完成情况(没有经过修改):
下面的代码是老师最后最后针对作业完成的标准代码,他只用了一个类:
下面讲解观察者模式:
那么在上面事件的调用过程中,为什么监听器比如ActionListener实现类里面特定事件的方法会在事件发生的时候被调用呢?这里用到了一种模式,[color=red]观察者模式[/color]。
[color=red]观察者模式(Observer)[/color]:
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个猪蹄对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,让他们能够自动更新自己。
观察者模式的组成:
1、[color=red]抽象主题角色[/color]:把所有对观察者对象的引用保存在一个集合中,每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口,可以增加和扇车观察者角色。一般用一个抽象类或接口来实现。
2、[color=red]抽象观察者角色[/color]:为所有具体的观察者定义一个接口,在得到主题的通知时更新自己。
3、[color=red]具体主题角色[/color]:在具体主题内部状态改变时,给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
4、[color=red]具体观察者角色[/color]:该角色实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态相协调。如果需要,具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现。
所谓的注册就是将一个观察者的对象应用存放到了主题里面去了么(一般是集合)。我们的方法最后肯定是主题来执行的呀,一定不是平白无故的自己就去执行了呀。永远没有自动调用这一回事,自动调用只是一种表面现象,是你还没有明白底层是怎么实现的。
下面的几个类是一个简单的典型的观察者模式程序:
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为观察者模式提供了一种支持,为其提供了类提供了接口来支持它。
[color=red]Observable[/color]类用于创建可以观测到你的程序中其他部分的子类【它是一个主题角色,它是一对多里面一的那一方,是有多个人去观测它】。当这种子类的对象发生变化时,观测类被通知。观测类必须实现定义了update()方法的[color=red]Observer接口[/color]。当一个观测程序被通知到一个被观测对象的改变时,update()方法被调用。
[color=red]Observable[/color]是我们的主题角色(我们继承这个类来创建我们自己的主题对象)。[color=red]Observer[/color]是抽象的观察者,我们实现它来定义自己的具体观察者。
[color=red]一定要重点查看Observable类的源码,一定要重点查看。仔细查看完之后Observable类的源码和我们最初自己实现的那个简单的观察者模式里面的ConcreteWatched 类代码特别相似,只是多了一个主题是否改变的Boolean变量和对它操纵的几个方法以及机制而已[/color]。
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()方法。[color=red]这导致了在观测对象中对update()方法的调用。注意---当对象在调用notifyObservers()方法之前,没有调用setChanged()方法,就不会有什么动作发生[/color]。[color=blue]在update()被调用之前,被观测对象必须调用setChanged()和notifyObservers()两种方法[/color]。
下面是针对观察者模式留的一个作业:
作业:
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);
}
}