观察者模式是对象的行为模式，顾名思义，即存在观察者和被观察者。 观察者模式可以让多个观察者同时监听同一个被观察对象，当被观察对象发生变化时，并通知所有观察者，使各个观察者能作出相应的响应。适当地运用观察者模式，能提高自身代码的设计水平。
观察者模式理解和编码都比较简单，通常包括以下步骤：
1. 设计观察者接口类；
2. 观察者类实现该接口；
3. 设计被观察者抽象类，该类中提供一些方法，如：添加观察者对象，删除观察者对象，把事件通知给各个观察者对象；
4. 设计被观察者类，继承被观察者抽象类，在该类中，可以根据需要在该类中，可以定义方法：被观察者是否发生变化
以上四步，即完成了观察者模式的设计。下面代码分类进行描述以上步骤：
package Observer;
import java.util.Enumeration;
import java.util.Vector;
abstract public class Subject {
private Vector observersVector = new java.util.Vector();
public void attach(Observer observer){
observersVector.addElement(observer);
System.out.println("Attached an observer.");
}
public void detach(Observer observer){
observersVector.removeElement(observer);
}
public void notifyObservers(){
java.util.Enumeration enumeration = observers();
while(enumeration.hasMoreElements()){
System.out.println("Before notifying");
((Observer)enumeration.nextElement()).update();
}
}
public Enumeration observers(){
return ((java.util.Vector)observersVector.clone()).elements();
}
}
package Observer;
public class ConcreteSubject extends Subject{
private String state;
public void change(String newState){
state = newState;
this.notifyObservers();
}
}
package Observer;
public interface Observer {
void update();
}
package Observer;
public class ConcreteObserver implements Observer{
public void update(){
System.out.println("I am notified.");
}
}
package Observer;
public class Client {
private static ConcreteSubject subject;
private static Observer observer1;
private static Observer observer2;
public static void main(String[] args){
subject = new ConcreteSubject();
observer1 = new ConcreteObserver();
observer2 = new ConcreteObserver();
subject.attach(observer1);
subject.attach(observer2);
subject.change("new state");
}
}
运行结果是：
Attached an observer.
Attached an observer.
Before notifying
I am notified.
Before notifying
I am notified.
在java中提供了Observerable类和Observer接口来实现观察者模式
public class Observable
extends Object
此类表示模型视图范例中的 observable 对象，或者说“数据”。可将其子类化，表示应用程序想要观察的对象（即被观察者）。
一个 observable 对象可以有一个或多个观察者。观察者可以是实现了 Observer 接口的任意对象。一个 observable 实例改变后，调用 Observable 的 notifyObservers 方法的应用程序会通过调用观察者的 update 方法来通知观察者该实例发生了改变。
未指定发送通知的顺序。Observable 类中所提供的默认实现将按照其注册的重要性顺序来通知 Observers，但是子类可能改变此顺序，从而使用非固定顺序在单独的线程上发送通知，或者也可能保证其子类遵从其所选择的顺序。
注意，此通知机制与线程无关，并且与 Object 类的 wait 和 notify 机制完全独立。
新创建一个 observable 对象时，其观察者集合是空的。当且仅当 equals 方法为两个观察者返回 true 时，才认为它们是相同的。
public interface Observer
一个可在观察者要得到 observable 对象更改通知时可实现 Observer 接口的类。
给个用java机制来实现观察者模式的例子
在java机制中Observable类相当于抽象主题角色，我们定义具体主题角色来继承该类
Observer 接口相当于抽象观察者角色，我们定义具体观察者角色来实现该接口
所以这两个抽象角色我们不用编写了 只需编写两个具体角色
//－－－－具体观察对象角色
package Observer.javaObserver;
import java.util.Observable;
public class Product extends Observable{
private String name;
private float price;
public String getName(){
return name;
}
public void setName(String name){
= name;
// 设置变化点
setChanged();
notifyObservers(name);//通知观察者
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
//设置变化点
setChanged();
notifyObservers(new Float(price));
}
public void saveToDb(){
System.out.println("saveToDb");
}
}
//------------ 两个具体观察者角色
package Observer.javaObserver;
import java.util.Observable;
import java.util.Observer;
public class NameObserver implements Observer {
private String name = null;
public void update(Observable obj, Object arg){
if(arg instanceof String){
name = (String)arg;
System.out.println("NameObserver:name changed to " + name);
}
}
}
package Observer.javaObserver;
import java.util.Observable;
import java.util.Observer;
public class PriceObserver implements Observer{
private float price=0;
public void update(Observable obj, Object arg){
if(arg instanceof Float){
price = ((Float)arg).floatValue();
System.out.println("PriceObserver: price change to" + price);
}
}
}
//－－－－测试程序
package Observer.javaObserver;
import java.util.Observer;
public class Test {
public static void main(String[] args){
Product product = new Product();
Observer nameObs = new NameObserver();
Observer priceObs = new PriceObserver();
product.addObserver(nameObs);
product.addObserver(priceObs);
product.setName("apple");
product.setPrice(9.22f);
product.setName("Apple");
product.setPrice(9.88f);
}
}
//－－－运行结果
NameObserver:name changed to apple
PriceObserver: price change to9.22
NameObserver:name changed to Apple
PriceObserver: price change to9.88
