Java（观察者模式 observer）

/**
 * 被观察者接口（抽象的被观察者接口）
 * 
 *
 */
public interface AbstractWatched {
	/**
	 * 增加一个观察者
	 * @param abstractWatcher
	 */
	public void addWatcher(AbstractWatcher watcher);
	
	/**
	 * 删除一个观察者
	 * @param abstractWatcher
	 */
	public void removeWatcher(AbstractWatcher watcher);
	
	/**
	 * 删除所有观察者
	 */
	public void removeAllWatchers();
	
	/**
	 * 改变被观察者的状态
	 */
	public void changeStatus();
}

/**
 * 抽象的观察者角色
 * 
 *
 */
public interface AbstractWatcher {
    /**
     * 观察者的更新操作
     */
    public void update();
}

/**
 * 具体的被观察者实现
 * 
 *
 */
public class ConcreteWatched implements AbstractWatched {
	
	private List<AbstractWatcher> watchers = new ArrayList<AbstractWatcher>();

	@Override
	public void addWatcher(AbstractWatcher watcher) {
		watchers.add(watcher);
	}

	@Override
	public void changeStatus() {
		System.out.println("status changed");
		for (AbstractWatcher watcher : watchers) {
			watcher.update();//通知所有的观察者自动更新
		}
	}

	@Override
	public void removeAllWatchers() {
		watchers.clear();
	}

	@Override
	public void removeWatcher(AbstractWatcher watcher) {
		watchers.remove(watcher);
	}

}

/**
 * 具体的观察者角色
 * 
 *
 */
public class ConcreteWatcher implements AbstractWatcher {

	@Override
	public void update() {
		System.out.println("watcher updated");
	}

}

public class Client {
	public static void main(String[] args) {
		AbstractWatched watched = new ConcreteWatched();
		
		AbstractWatcher watcher1 = new ConcreteWatcher();
		watched.addWatcher(watcher1);
		
		AbstractWatcher watcher2 = new ConcreteWatcher();
		watched.addWatcher(watcher2);
		
		AbstractWatcher watcher3 = new ConcreteWatcher();
		watched.addWatcher(watcher3);
		
		watched.changeStatus();
		
		System.out.println("-------------------------");
		
		watched.removeWatcher(watcher1);
		
		watched.changeStatus();
		
	}
}

观察者模式在Java中占据举足轻重的位置，在AWT1.1和使用SAX解析xml文件中，都使用到观察者模式。所以Java内置也对观察者模式提供了API

import java.util.Observable;

/**
 * 被观察者，需要继承Observable类
 * @author yinhao
 *
 */
public class Watched extends Observable {
	//测试方法
	public void count(int number){
		for (;number >= 0; number--) {
			setChanged();//标识下，被观察者已经改变了，必须调用该方法，才会通知其他的观察者
			notifyObservers();//通知观察者状态已改变
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

import java.util.Observable;
import java.util.Observer;
/**
 * 观察者，需要实现Observer接口
 * @author yinhao
 *
 */
public class Watcher implements Observer {

	@Override
	public void update(Observable o, Object arg) {
		System.out.println("updated");
	}

}

public class Client {
	public static void main(String[] args) {
		Watched watched = new Watched();
		Watcher watcher = new Watcher();
		watched.addObserver(watcher);
		watched.count(10);
	}
}