如何实现简单的观察者模式
接下来我们实现壹個简单的被观察者类 ExampleObservable ，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
import
java.util.Observable;
public
class
ExampleObservable
extends
Observable {
int
data =
0
;
public
void
setData(
int
data){
this
.data = data;
this
.setChanged();
//标记此 Observable对象为已改变的对象
this
.notifyObservers();
//通知所有的观察者
}
}
|
再实现壹個观察者类 ExampleObserver，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
import
java.util.Observable;
import
java.util.Observer;
public
class
ExampleObserver
implements
Observer {
//有被观察者发生变化，自动调用对应观察者的update方法
@Override
public
void
update(Observable object, Object argument) {
//通过强制类型转换获取被观察者对象
ExampleObservable example = (ExampleObservable)object;
System.out.println(
"example.data changed, the new value of data is "
+ example.data);
}
}
|
我们再写壹個简单的测试类来测试下它是否运行正确，代码如下：
|
1
2
3
4
5
6
7
8
9
10
|
public
class
Main {
public
static
void
main(String[] args) {
ExampleObservable example =
new
ExampleObservable();
example.addObserver(
new
ExampleObserver());
//给example这个被观察者添加观察者，允许添加多個观察者
example.setData(
2
);
example.setData(-
5
);
example.setData(
9999
);
}
}
|
运行之后在控制台输出如下结果：
|
1
2
3
|
example.data changed, the
new
value of data is
2
example.data changed, the
new
value of data is -
5
example.data changed, the
new
value of data is
9999
|
通过输出结果我们可以了解到，当 ExampleObservable 类的实例 example 的成员变量 data 的值发生改变时，ExampleObserver 对象都能够监测到，然后调用 update() 方法打印壹句话到控制台，说明以上的结果是符合我们预期的。
既是观察者又是被观察者
对于壹個类而言，可以既是观察者又是被观察者，只要既继承 Observable 类，又实现 Observer 接口就可以了。接下来给出壹個类似的例子。例子中 ObserverA 和 ObserverB 既是观察者又是被观察者，它们互相监听着对方的改变。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
//ObserverA.java
import
java.util.Observable;
import
java.util.Observer;
public
class
ObserverA
extends
Observable
implements
Observer {
@Override
public
void
update(Observable object, Object arg) {
ObserverB observerB = (ObserverB)object;
System.out.println(
"observerB changed, the new value of observerB.data is "
+ observerB.data);
this
.setChanged();
this
.notifyObservers();
}
}
//ObserverB.java
import
java.util.Observable;
import
java.util.Observer;
public
class
ObserverB
extends
Observable
implements
Observer {
int
data =
0
;
@Override
public
void
update(Observable object, Object arg) {
System.out.println(
"ObserverB found that ObserverA changed..."
);
}
public
void
setData(
int
data){
this
.data = data;
this
.setChanged();
this
.notifyObservers();
}
}
//Main.java
import
net.oschina.bairrfhoinn.multiply.ObserverA;
import
net.oschina.bairrfhoinn.multiply.ObserverB;
public
class
Main {
public
static
void
main(String[] args) {
ObserverA a =
new
ObserverA();
ObserverB b =
new
ObserverB();
a.addObserver(b);
b.addObserver(a);
b.setData(
2
);
}
}
|
运行之后的结果为：
|
1
2
|
observerB changed, the
new
value of observerB.data is
2
ObserverB found that ObserverA changed...
|
之所以会出现上述运行结果，最初 ObserverA 和 ObserverB 相互之间作为观察者与被观察者，但是 ObserverB 的实例 b 先调用的 setData() 方法，然后 ObserverA 的实例 a 观察到了这個变化，于是调用了本类的 update 方法打印出了第壹行，紧接着 ObserverA 的 update() 方法在方法体中声明了自己发生了变化，于是 ObserverB 观察了这個情况，也调用了自身的 update() 方法并打印了第二句话。