Java设计模式——观察者模式

观察者模式定义：定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它所有依赖者都会受到通知并自动更新。具体实例可以参考Android中的广播。下面实现一个观察者模式的Demo。

主题接口

package test;

/**
 * 定义主题接口
 * @author CYL
 *
 */
public interface Subject {

	public void registerObserver(Observer obs);// 注册观察者

	public void removeObserver(Observer obs);// 解注册

	public void notifyObservers();// 通知观察者更新

}

主题接口的具体实现类

package test;

import java.util.ArrayList;
import java.util.List;

/**
 * 具体的主题类，实现类Subject主题接口
 * 
 * @author CYL
 * 
 */
public class ConcreteSubject implements Subject {

	private int state = 0;

	private List<Observer> myObservers = new ArrayList<Observer>();

	// 改变主题的状态，通过notifyObservers（）方法，实现观察者接口内的update（）
	public void changeState(int newState) {
		if (newState != state) {
			System.out.println("ConcreateSubject state changed! \n");

			this.state = newState;
			notifyObservers();
		}
	}

	// 如果myObservers中不包含观察者obs，则将obs添加到myObservers列表中
	@Override
	public void registerObserver(Observer obs) {
		if (myObservers.contains(obs)) {
			return;
		} else {
			myObservers.add(obs);
		}
	}

	// 解注册，当myObservers列表中包含obs时，则将其移除
	@Override
	public void removeObserver(Observer obs) {
		if (myObservers.contains(obs)) {
			myObservers.remove(obs);
		}
	}

	// 通知列表myObservers中所有对象进行更新
	@Override
	public void notifyObservers() {
		for (Observer obs : myObservers) {
			obs.update();
		}
	}

}

观察者接口

package test;
/**
 * 定义观察者接口
 * @author CYL
 *
 */
public interface Observer {

	public void update();
}

观察者接口的一个实现类

package test;

public class ConcreteObserver implements Observer {

	// 复写Observer接口中的update（）方法
	@Override
	public void update() {
		System.out.println("ConcreteObserver updated!");
	}

}

观察者接口的另一个实现类

package test;

public class AnotherObserver implements Observer {

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

}

测试类

package test;

public class Test {

	public static void main(String[] args) {
		ConcreteSubject subject = new ConcreteSubject();// 实例化一个具体的主题类对象
		ConcreteObserver cObs = new ConcreteObserver();// 实例化两个具体的观察者类对象
		AnotherObserver aObs = new AnotherObserver();

		// 在主题对象中注册两个观察者对象
		System.out.println("register ConcreteObserver!");
		subject.registerObserver(cObs);
		System.out.println("register AnotherObserver!");
		subject.registerObserver(aObs);

		// 改变主题状态
		subject.changeState(2);

		System.out.println("\n");
		System.out.println("remove ConsreteObserver!");
		subject.removeObserver(cObs);// 解注册观察者对象cObs

		subject.changeState(3);
		System.out.println("\n");

		System.out.println("remove AnotherObserver!");
		subject.removeObserver(aObs);

		subject.changeState(4);
	}
}

输出结果：

register ConcreteObserver!
register AnotherObserver!
ConcreateSubject state changed! 


ConcreteObserver updated!
AnotherObserver updated!




remove ConsreteObserver!
ConcreateSubject state changed! 


AnotherObserver updated!




remove AnotherObserver!
ConcreateSubject state changed!