设计模式 观察者模式 Observer

 

/**
 *@author     ET
 */

 

 

 

我的女儿林格最近越来越可爱了，但是也越来越淘气了，醒了就需要吃饭，总是离不开人，我总是要看着她，妈妈也要形影不离，生怕有意外发生。

 

如果上面的描述如何用程序实现呢？

 

把我设计成一个线程，不停的监视着宝宝的状态，妈妈设计成另外一个线程，也不停的监视着宝宝的状态，当宝宝醒来的时候在调用喂饭的方法么？

 

答案肯定是no，那样我一天什么都不能去做，妈妈也是同样，连洗尿布的时间都没有，因为两个人都忙着监护宝宝的状态呢。对，线程就是这样工作的。

 

那有没有一种其他的方法改善如此场面呢？那就是观察者模式。

 

首先介绍两个类。

 

//被观察者
import java.util.Observable;
//观察者
import java.util.Observer;

 

 

 

这是SUN提供给我们的，已经封装好的一个类，和一个接口，当然我们也可以自己实现功能。

下面看看JDK的具体实现。

 

 

package java.util;
public class Observable {
    private boolean changed = false;
    private Vector obs;
   
//构造函数
    public Observable() {
	obs = new Vector();
    }

    /**
     * 添加一个观察者
     */
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
	if (!obs.contains(o)) {
	    obs.addElement(o);
	}
    }

    /**
     * 删除一个观察者
     */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    /**
     * public void notifyObservers(Object arg)  方法的重载
     */
    public void notifyObservers() {
	notifyObservers(null);
    }

    /**
     * 被观察者发出一个事件，应该调用此方法。比如女儿醒了
     */
    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();
    }

    /**
     * 设置改变状态
     */
    protected synchronized void setChanged() {
	changed = true;
    }

    /**
     * 清除改变状态
     */
    protected synchronized void clearChanged() {
	changed = false;
    }

    /**
     * 获取改变状态
     */
    public synchronized boolean hasChanged() {
	return changed;
    }

    /**
     * 观察者数量
     */
    public synchronized int countObservers() {
	return obs.size();
    }
}

 

 以上可以理解为一个被观察者的父类。

 

 

package java.util;


public interface Observer {
   
    void update(Observable o, Object arg);
}

 

 

观察者是一个接口。

 

 

 

这次让我们来看具体的实现：

 

女儿的类，继承被观察者类

 

 

import java.util.Observable;

public class MyDaughter extends Observable {
    
    public void wake(){
	System.out.println("我睡醒啦");
	this.setChanged();
	this.notifyObservers(this);
	//this.clearChanged();
    }
    
}

 

 

 

作为父母的观察者

 

 

public class Mother implements Observer {

    public void update(Observable arg0, Object arg1) {
	System.out.println("妈妈给准备饭吃！");
    }

}


public class Father implements Observer {

    public void update(Observable o, Object arg) {
	System.out.println("爸爸抱抱！");
    }

}

 

 

测试类

 

 

 

public class Test {

    public static void main(String[] args) {
	//创建被观察者对象
	MyDaughter mDaughter = new MyDaughter();
//	创建观察者对象
	Mother mother = new Mother();
	Father father = new Father();
//	添加观察者
	mDaughter.addObserver(mother);
	mDaughter.addObserver(father);
	
//	宝宝醒来
	mDaughter.wake();
    }

}

 

 

 

运行后 在控制台输出：

 

 输出

我睡醒啦
爸爸抱抱！
妈妈给准备饭吃！

 

这样我们就简单的实现了一个观察者模式，当然你不用jdk提供的接口也可以，自己去实现就是了。