以前對於這個機制理解不夠深刻，現在重新整理下思路。

一、建模

我理解的介面回撥就是，我這個類實現了一個接口裡的方法doSomething，然後註冊到你這裡，然後我就去做別的事情去了，你在某個觸發的時機回頭來呼叫我doSomething的方法。好比，我給你打電話問某個難題，你電話裡想不出來，於是說等想到了再回我電話。於是介面回撥機制比喻模型如下

第一步：

首先，你我得約定，這個實現的方法是咋樣的，叫什麼名字，需要傳入傳出什麼。為什麼要這樣呢？你我得約定電話聯絡，不是微信扣扣。這就是約定的介面。

我們約定當你想到問題的答案就回我，所以這裡傳入引數是你想到的答案。

1. public
   interface ContactInterface {  
2. publicvoid callBackByTel(String answer);  
3. }  

第二步：

我得先打電話（註冊）到你那，告訴你我的問題是什麼。是吧。

所以你那裡必須有個方法讓我告訴你問題相關事宜（註冊）。

1. publicvoid setCallBack(String who,String question,ContactInterface callBack) {  
2. this.who = who;          
3. System.out.println("你說：當前聯絡到我的人是"+who+"，問題是"
   +question);  
4.        this.callBack =callBack;  
5.    }  

第三步：

當你想到問題的答案後，打電話告訴我答案，即回撥我傳進來的方法。

1. publicvoid handleThings(){  
2.  //假如你現在正在想問題的答案，需要一點時間
3.  for(int i=0;i<100000;i++){   
4.               if(i == 0){  
5.                       System.out.println("你正在思考問題.....");  
6.               }  
7.         }  
8.  String answer = "答案是A"
   ;  
9.  //想到問題的辦法了
10.  System.out.println("你說：想到答案了，準備打回去給"+who+"告訴他答案");  
11.  callBack.callBackByTel(answer);  
12.  }  

OK，整個機制構成三要素就是：我（客戶端），你（服務端），約定（介面）

 我類——

1. publicclass Me {  
2.      publicstaticvoid main(String[] args){    
3.          Me me = new Me();  
4.          me.hasQuestion();  
5.      }  
6.      privatevoid hasQuestion(){  
7.          //現在有問題想不出來答案，想去問你
8.          You you = new You();  
9.          you.setCallBack("蝸牛", "某道題答案是什麼？", new ContactInterface() {  
10.             @Override
11.             publicvoid callBackByTel(String answer) {  
12.                 System.out.println("我說：嗯，好的，我收到答案了:"+answer+"，謝謝");  
13.             }  
14.         });  
15.          //你接到電話，起床開始思考問題
16.         new Thread(you).start();  
17.      }  
18. }  

1. package lin.callback.test;  
2. publicclass You implements Runnable{  
3.     private String who;  
4.      private ContactInterface callBack;    
5.      public You() {  
6.             // TODO Auto-generated constructor stub
7.         }  
8.     //呼叫此方法就表示有人聯絡你了，註冊到你這來
9.      publicvoid setCallBack(String who,String question,ContactInterface callBack) {  
10.          this.who = who;      
11.          System.out.println("你說：當前聯絡到我的人是"+who+"，問題是"+question);  
12.             this.callBack =callBack;  
13.         }  
14.      publicvoid handleThings(){  
15.          //假如你現在正在想問題的答案，需要一點時間
16.          for(int i=0;i<100000;i++){    
17.                   if(i == 0){  
18.                       System.out.println("你正在思考問題.....");  
19.                   }  
20.             }  
21.          String answer = "答案是A";  
22.          //想到問題的辦法了
23.          System.out.println("你說：想到答案了，準備打回去給"+who+"告訴他答案");  
24.          callBack.callBackByTel(answer);  
25.      }  
26.     /* (non-Javadoc) 
27.      * @see java.lang.Runnable#run() 
28.      */
29.     @Override
30.     publicvoid run() {  
31.         try {  
32.             Thread.sleep(1000);  
33.             handleThings();  
34.         } catch (Exception e) {  
35.             e.printStackTrace();  
36.         }  
37.     }  
38. }  

1. publicinterface ContactInterface {  
2.     publicvoid callBackByTel(String answer);  
3. }  

驗證結果：

二、總結

Java中沒有函式指標這一說，因為java沒有指標，但是並不代表著它不會使用這個功能。事實上，引用就是實現了指標的功能。

回撥方法就是一個通過方法指標來呼叫的方法。如果我將這個方法的指標（地址，引用）通過形參傳遞到另一個類的某個方法裡，那麼當這個類呼叫該方法裡面我所傳入的指標時，就能呼叫我這邊的方法。

整個過程就是我傳入方法A的地址，你接收，並在某個時刻回撥我這邊的A方法。

由於java沒辦法操作指標，於是它用介面來實現。

JAVA方法回撥是一種耦合設計思想。作為一種架構，必須有自己的執行環境，並且提供使用者的實現介面。

主要步驟如下：

•  定義介面 Callback ,包含回撥方法 callback()；
• 服務端提供註冊的方法，並設定在某個條件下會回撥介面方法；
• 客戶端提供介面的實現方法，並註冊到服務端，把方法地址傳進去。

這樣,在需要的時候,可用Caller物件的mCallback介面成員呼叫callback()方法,完成回調了。

三、Android中的回撥機制

在android中回撥機制被大量使用。

比如，在Activity中定義了很多生命週期的不同狀態要呼叫的方法，這些方法都是空實現，系統框架要呼叫，使用者也要呼叫來實現。或者更直接的是按鍵點選的實現方法。

1. loginButton.setOnClickListener(new OnClickListener() {  
2. @Override
3. publicvoid onClick(View v) {  
4. // TODO Auto-generated method stub
5. }  
6. });  

明顯，OnClickListener就是android系統所約定好的介面，然後我們寫的應用程式就是客戶端，android 系統就是服務端。模型關係如下圖所示：

以上可以看出，介面(系統框架)是系統提供的，介面的實現是使用者實現的，這樣可以達到介面統一，實現不同的效果。

系統在不同的狀態“回撥”我們的實現類，來達到介面和實現的分類。