观察者模式

一、背景

       试想现在有一个对象A的状态变了，另一个对象B要想知道A变了怎么办？在A中new 一个B实例 然后调用B的接收方法？如果另一个对象C也想知道呢？同样D也想知道呢？如果这样的话是不是耦合度太高了？所以观察者模式便产生了。

二、概念

       记得看谍战片的时候，双方都会派卧底到对方监视，当被监视者有所动作是，卧底便通知对方采取行动。类似的观察者模式也是这样，当一个对象发生变化时，其他所有依赖该对象的对象会收到通知，并随着变化。

三、代码实例

import java.util.Enumeration;
import java.util.Vector;

/**
 *  被观察者抽象接口
 */
interface Subject {
	/**
	 * 添加观察者
	 */
	public void addObserver(Observer observer);

	/**
	 * 删除观察者
	 */
	public void removeObserver(Observer observer);

	/**
	 * 通知所有观察者
	 */
	public void notifyObservers();

	/**
	 * 自我改变方法
	 */
	public void operation();
}

/**
 *  被观察者抽象类
 */
abstract class AbstractSubject implements Subject {
	private Vector<Observer> observers = new Vector<Observer>();

	@Override
	public void addObserver(Observer observer) {
		// TODO Auto-generated method stub
		observers.add(observer);
	}

	@Override
	public void removeObserver(Observer observer) {
		// TODO Auto-generated method stub
		observers.remove(observer);
	}

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		Enumeration<Observer> enumeration = observers.elements();
		while (enumeration.hasMoreElements()) {
			enumeration.nextElement().update();
		}
	}
}


/**
 *被观察者具体实现类
 */
class MySubject extends AbstractSubject {

	@Override
	public void operation() {
		// TODO Auto-generated method stub
		System.out.println("我是被观察者MySubject我的状态改变了");
		notifyObservers();
	}

}

/**
 * 观察者抽象接口
 */
interface Observer {
	public void update();
}

class ObserverA implements Observer {

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("观察者ObserverA方法update执行！");
	}
}

class ObserverB implements Observer {

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("观察者ObserverB方法update执行！");
	}

}
/**
 *观察者模式： 观察者模式所描述的是当一个对象发生变化时，通知依赖它的对象，并产生相应的改变。
 */
public class ObserverPatternDemo {
	public static void main(String agrs[]) {
		Subject sb = new MySubject();
		Observer obA = new ObserverA();
		Observer obB = new ObserverB();
		sb.addObserver(obA);
		sb.addObserver(obB);
		sb.removeObserver(obB);
		sb.operation();
	}
}