Java 设计模式_观察者模式
本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/76285929
定义对象之间的一种一对多依赖关系, 让多个观察者对象同时监听某一特定对象. 使得每当该特定对象状态发生改变时, 其相关依赖的观察者对象都会收到通知, 使他们能够进行自我更新等操作
观察者模式分为: 观察者模式 / 回调模式
观察者模式
/**
* 观察者接口
* @author Luzhuo
*/
public interface Observer {
/**
* 更新接口, 用于通知观察者数据已更新
* @param state
*/
void update(String message);
}
/**
* 具体的观察者对象
* @author Luzhuo
*/
public class ContentObserver implements Observer{
/**
* 需手动调用Observable对象的注册方法
*/
public ContentObserver(){ }
public ContentObserver(Observable observable) {
observable.register(this);
}
@Override
public void update(String message) {
System.out.println("观察者收到信息: " + message);
}
}
- 定义观察者ContentObserver , 用于观察被观察的对象
/**
* 被观察的对象抽象类
* @author Luzhuo
*/
public abstract class Observable {
/**
* 保存注册的观察者对象
*/
private List<Observer> observers = new ArrayList<>();
/**
* 注册观察者对象
* @param observer
*/
public void register(Observer observer){
observers.add(observer);
}
/**
* 注销观察者对象
* @param observer
*/
public void unRegister(Observer observer){
observers.remove(observer);
}
/**
* 通知所有注册的观察者对象
* @param newState
*/
public void notifyObservers(String newState){
for (Observer observer : observers){
observer.update(newState);
}
}
}
/**
* 被观察的对象具体类
* @author Luzhuo
*/
public class ContentObservable extends Observable{
private String mMessage;
public String getMessage(){
return mMessage;
}
public void change(String message){
System.out.println("被观察者收到信息: " + message);
mMessage = message;
// 状态发生改变, 通知所有已注册的观察者
notifyObservers(message);
}
}
- 定义被观察对象ContentObservable ,首先要把观察者添加到自己(被观察对象)的集合中, 当自己发生改变时,通过调用每个观察者的 update 接口告知数据改变
public class Test {
public static void main(String[] args) {
// 创建被观察的对象
ContentObservable observable = new ContentObservable();
// 创建观察者对象, 并将观察者注册到被观察者对象上, 以便被观察者发生变化时通知观察者
Observer observer = new ContentObserver(observable);
// 创建多个观察者
new ContentObserver(observable);
new ContentObserver(observable);
// 被观察者状态发生改变
observable.change("change");
// 注销观察者
observable.unRegister(observer);
observable.change("change111");
}
}
使用系统自带的观察者模式
/**
* 具体观察者对象
* @author Luzhuo
*/
public class TargetObserver implements Observer{
/**
* 需手动调用Observable对象的注册方法
*/
public TargetObserver(){ }
public TargetObserver(Observable observable) {
observable.addObserver(this);
}
@Override
public void update(Observable o, Object arg) {
String message = ((TargetObservable)o).getMessage();
System.out.println("观察者收到消息: " + message);
}
}
- 定义观察者对象TargetObserver
public class TargetObservable extends Observable{
private String message;
public String getMessage(){
return message;
}
public void change(String message){
System.out.println("被观察者收到信息: " + message);
this.message = message;
this.setChanged();
this.notifyObservers(message);
}
}
- 定义被观察者对象.
- 可见, 不管是定义观察者对象,还是定义被观察者对象, (甚至使用方法)都与自己写的观察者模式代码相差无几
public class Test {
public static void main(String[] args) {
// 创建被观察者对象
TargetObservable observable = new TargetObservable();
// 创建观察者对象
Observer observer = new TargetObserver(observable);
// 创建多个观察者
new TargetObserver(observable);
new TargetObserver(observable);
// 被观察者状态发生改变
observable.change("start");
observable.change("stop");
// 注销观察者
observable.deleteObserver(observer);
observable.change("run");
}
}
回调模式
/**
* 回调接口, 一般用于异步中, 属于简洁型的观察者模式
* @author Luzhuo
*/
public class AsyncTask {
// 定义回调接口的成员变量
private Callback callback;
/**
* 声明回调接口
* @author Luzhuo
*/
public interface Callback{
public abstract void onCallback();
}
/**
* 设置回调接口对象成员变量
* @param callback
*/
public void setCallbackListener(Callback callback){
this.callback = callback;
}
/**
* 调用回调接口对象中的方法
*/
public void call(){
callback.onCallback();
}
}
- 回调模式可算是一种迷你型的观察者模式, 非常轻巧, 经常用于异步任务的回调
public class Test {
public static void main(String[] args) {
AsyncTask task = new AsyncTask();
task.setCallbackListener(callback);
task.call();
}
private static AsyncTask.Callback callback = new AsyncTask.Callback() {
@Override
public void onCallback() {
System.out.println("这是一个异步任务的回调.");
}
};
}