回调和观察者模式的关系

Android的框架中有非常多的地方使用了回调的模式，例如Activity的生命周期，按钮的点击事件等。

下面是回调的基本模型：

[java] view plain copy

1. public class A {  
2.     private CallBack callback;  
3.     //注册一个事件  
4.     public void register(CallBack callback){  
5.         this.callback = callback;  
6.     }  
7.     // 需要调用的时候回调  
8.     public void call(){  
9.         callback.oncall();  
10.     }  
11. }  

[java] view plain copy

1. public interface CallBack {  
2.     public void oncall();  
3. }  

[java] view plain copy

1. public static void main(String[] args) {  
2.     A a = new A();  
3.     a.register(new CallBack() {  
4.         @Override  
5.         public void oncall() {  
6.             System.out.println("回调函数被调用");  
7.         }  
8.     });  
9.     a.call();  
10. }  

如果把类A改成Button，CallBack改成OnClickListener，register函数改成setOnclickListener，和android里面设置点击事件是一样的。callback.oncall();只是在点击事件激发后调用而已。

观察者模式：

定义对象间的一对多的依赖关系，当一个对象状态发生改变时，所有依赖他的对象都得到通知并被自动更新。

目标：

[java] view plain copy

1. public class Subject {  
2.   
3.     List<Observer> lists = new ArrayList<Observer>();  
4.       
5.     //注册一个事件  
6.     public void register(Observer observer){  
7.         lists.add(observer);  
8.     }  
9.   
10.     public void _notify(){  
11.         for (Observer observer : lists) {  
12.             observer.update();  
13.         }  
14.     }  
15.       
16.     public void unRegister(Observer observer){  
17.         lists.remove(observer);  
18.     }  
19. }  

观察者抽象接口

[java] view plain copy

1. public interface Observer {  
2.     public void update();  
3. }  

观察者1

[java] view plain copy

1. public class ConcreteObserver1 implements  Observer{  
2.   
3.     public void update() {  
4.         System.out.println("ConcreteObserver1获得更新");  
5.     }  
6. }  

观察者2

[java] view plain copy

1. public class ConcreteObserver2 implements  Observer{  
2.   
3.     public void update() {  
4.         System.out.println("ConcreteObserver2获得更新");  
5.     }  
6. }  

[java] view plain copy

1. public static void main(String[] args) {  
2.     Observer observer1 = new ConcreteObserver1();  
3.     Observer observer2 = new ConcreteObserver2();  
4.     Subject subject = new Subject();  
5.     subject.register(observer1);  
6.     subject.register(observer2);  
7.     subject._notify();  
8.     //取消观察者1的注册  
9.     subject.unRegister(observer1);  
10.     subject._notify();  
11. }  

目标对象保存了各个观察者的引用，当需要通知时发送通知。

实际上，回调是观察者模式的简单形式。观察者模式也就是将回调上升到设计模式的理论高度上了而已。

将回调例子中的main方法改成        

[html] view plain copy

1. public static void main(String[] args) {  
2.     CallBack callback = new CallBackImp();  
3.     A a = new A();  
4.     a.register(callback);  
5.     a.call();  
6. }  

增加CallBack的实现类CallBackImp

[java] view plain copy

1. public class CallBackImp implements CallBack{  
2.     @Override  
3.     public void oncall() {  
4.         System.out.println("回调函数被调用");  
5.     }  
6. }  

这样看来，是一致的，区别是观察者模式里面目标类维护了所有观察者的引用，而回调里面只是维护了一个引用。