There are many places in the Android framework that use callback mode, such as the life cycle of Activity, button click event, etc.

The following is the basic model of callback:

1. public class A {  
2.     private CallBack callback;  
3.     //Register an event  
4.     public void register(CallBack callback){  
5.         this.callback = callback;  
6.     }  
7.     //Call back when needed  
8.     public void call(){  
9.         callback.oncall();  
10.     }  
11. }  

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

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("Callback function called");  
7.         }  
8.     });  
9.     a.call();  
10. }  

If you change class A to Button, CallBack to OnClickListener, and register to setOnclickListener, it is the same as setting click event in android. callback.oncall(); it is called only after clicking the event.

Observer mode:

Define one to many dependencies between objects. When the state of an object changes, all objects that depend on it are notified and updated automatically.

Objectives:

1. public class Subject {  
2.   
3.     List<Observer> lists = new ArrayList<Observer>();  
4.       
5.     //Register an event  
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. }  

Observer abstract interface

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

Observer 1

1. public class ConcreteObserver1 implements  Observer{  
2.   
3.     public void update() {  
4.         System.out.println("ConcreteObserver1 Get updates");  
5.     }  
6. }  

Observer 2

1. public class ConcreteObserver2 implements  Observer{  
2.   
3.     public void update() {  
4.         System.out.println("ConcreteObserver2 Get updates");  
5.     }  
6. }  

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.     //Unregister observer 1  
9.     subject.unRegister(observer1);  
10.     subject._notify();  
11. }  

The target object holds the references of each observer and sends notifications when they are needed.

In fact, callbacks are a simple form of the observer pattern. The observer pattern is to raise the callback to the theoretical level of the design pattern.

Change the main method in the callback example to

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. }  

Add the implementation class CallBackImp of CallBack

1. public class CallBackImp implements CallBack{  
2.     @Override  
3.     public void oncall() {  
4.         System.out.println("Callback function called");  
5.     }  
6. }  

In this way, it is consistent. The difference is that the target class in observer mode maintains all observer references, while the callback only maintains one reference.

Original link: http://blog.csdn.net/cauchyweistrass/article/details/44593807