观察者模式定义了对象间一对多的关系，让一个或多个观察者对象观察一个主题对象。当主题对象的状态发生改变时，系统能通知所有的依赖于此对象的观察者，从而使得观察者对象能够自动更新。
在观察者模式中，被观察的对象常常也被称为目标或主题（Subject），依赖的对象也被称为观察者（Observer）。下面以一个简单的实例来示范观察者模式，程序先提供一个观察者接口：
|
1
2
3
4
|
//观察者接口
public
interface
Observer {
public
void
update(Observable o, Object obj);
}
|
上面Observer接口是一个观察者接口，程序中所有观察者都应该实现该接口。在该接口的update()方法中包含了一个Observable类型的参数，该参数代表被观察的对象，也就是前面介绍的目标或主题。此处Observable是一个抽象基类，程序中被观察者应该继承该抽象类。下面是Observable抽象类的代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
//目标对象的基类
public
abstract
class
Observable {
//用一个List来保存该对象上所有绑定的观察者
List<Observer> observers =
new
ArrayList<Observer>();
//这个方法用于从该目标对象上注册观察者
public
void
registObserver(Observer observer) {
observers.add(observer);
}
//移出该对象上绑定的观察者
public
void
removeObserver(Observer ovserver) {
observers.remove(observer);
}
//通知该目标对象上的所有观察者
public
void
notifyObservers(Object value) {
//遍历观察者集合，对每一个观察者都进行更新操作
for
(Observer observer: observers) {
observer.update(
this
, value);
}
}
}
|
该Observer抽象类是所有被观察者的基类，它主要提供了一个registObserver()方法用于注册一个新的观察者；并提供一个removeObserver()方法来移出一个已绑定的观察者。当具体被观察对象的状态发生改变时（比如setter方法中），会调用notifyObservers来通知所有观察者。
下面是一个具体的目标对象，该对象继承了上面的Observable基类：
|
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
|
public
class
Product
extends
Observable {
//定义两个属性
private
String name;
private
double
price;
//无参构造器
public
Product() {
}
//带参构造器
pubilc Product(String name,
double
price) {
this
.name = name;
this
.price = price;
}
public
String getName() {
return
name;
}
public
double
getPrice() {
return
price;
}
//当Product的name属性发生改变时，程序会触发该对象上注册的所有观察者
public
void
setName(String name) {
this
.name = name;
notifyObservers(name);
}
//当Product的price属性发生改变时，程序也会触发该对象上注册的所有观察者
public
void
setPrice(
double
price) {
this
.price = price;
notifyObservers(price);
}
}
|
正如程序中的代码所示，当程序调用Product的setName、setPrice方法来改变Product的name和price两个属性时，这两个方法将自动触发Observable基类的notifyObservers()方法。
接下来提供两个观察者，一个用于观察Product的name属性，另一个观察Product的price属性：
|
1
2
3
4
5
6
7
8
9
10
|
public
class
NameObserver
implements
Observer {
//观察者必须实现的update方法
@Override
public
void
update(Observable o, Object obj) {
if
(obj
instanceof
String) {
String name = (String)obj;
System.out.println(
"NameObserver："
+ o +
"，Product的Name已改为"
+ name);
}
}
}
|
PriceObserver.java：
|
1
2
3
4
5
6
7
8
9
10
|
public
class
PriceObserver
implements
Observer {
//观察者必须实现的update方法
@Override
public
void
update(Observable o, Object obj) {
if
(obj
instanceof
Double) {
double
price = (Double)obj;
System.out.println(
"PriceObserver："
+ o +
"，Product的Price已改为"
+ price);
}
}
}
|
最后创建一个Product对象（即目标对象），然后向该对象上绑定两个观察者：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
void
Test {
public
static
void
main(String[] args) {
//创建一个目标对象
Product p =
new
Product(
"桌子"
,
34.56
);
//创建两个观察者
NameObserver nameObserver =
new
NameObserver();
PriceObserver priceObserver =
new
PriceObserver();
//将这两个观察者绑定到目标对象上
p.registObserver(nameObserver);
p.registObserver(priceObserver);
//现在调用目标对象的set方法来修改属性值
p.setName(
"板凳"
);
p.setPrice(
12.34
);
}
}
|
运行上面的程序，将可以看到当Product的属性值发生改变时，注册在该Product上的NameObserver和PriceObserver将被触发。
纵观上面介绍的观察者模式，我们发现它通常包含4个角色：
-
被观察者（即目标对象）抽象基类（即上面的Observable）：它通常会持有多个观察者对象的引用。Java提供了java.util.Observable基类来代表被观察者的抽象基类，所以实际开发中无需自己开发这个角色
-
观察者接口（即上面的Observer）：该接口是所有被观察对象应该实现的接口，通常只包含一个抽象方法update。Java同样提供了java.util.Observer接口来代表观察者接口，所以实际开发中也无需自己开发这个角色
-
目标对象的实现类（即上面的Product）：该类继承自Observable基类
-
观察者对象的实现类（即上面的NameObserver和PriceObserver）：这些类实现Observer接口，实现update抽象方法
