Java 设计模式_观察者模式

Java 设计模式_观察者模式

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);
}
}

/**
* 被观察的对象抽象类
* @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);
}
}

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);
}
}

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("这是一个异步任务的回调.");
}
};
}