方法一：
定義一個接口，里面寫想要對外提供的方法，在邏輯層方法的參數里傳遞進去，讓在需要的時候調接口里的方法。
實例一：
public class SmsUtils {
public interface BackUpCallBack{
/**
* 短信調用前調用的方法
*/
public void beforeSmsBackup(int total);
/**
* 短信備份中調用的方法
* @param progress 當前備份的進度。
*/
public void onSmsBackup(int progress);
}
/**
* 短信的備份
* @param context 上下文
* @param od 進度條對話框
* @throws Exception
*/
public static void backupSms(Context context,BackUpCallBack backupCallback) throws Exception{
...
//開始備份的時候,設置進度條的最大值
backupCallback.beforeSmsBackup(cursor.getCount());
int progress = 0;
while (cursor.moveToNext()) {
Thread.sleep(500);
....
//備份過程中,增加進度
progress++;
backupCallback.onSmsBackup(progress);
}
serializer.endTag(null,"smss");
serializer.endDocument();
fos.close();
}
。。。
SmsUtils.backupSms(getApplicationContext(),new BackUpCallBack() {
@Override
public void onSmsBackup(int progress) {
pd.setProgress(progress);
}
@Override
public void beforeSmsBackup(int total) {
pd.setMax(total);
}
});
實例二：定義接口也可以寫在類外面
public interface HttpCallbackListener {
void onFinish(String response);
void onError(Exception e);
}
public class HttpUtil {
public static void sendHttpRequest(final String address,
final HttpCallbackListener listener) {
new Thread(new Runnable() {
@Override
public void run() {
HttpURLConnection connection = null;
try {
...
while ((line = reader.readLine()) != null) {
response.append(line);
}
if (listener != null) {
// 回調onFinish()方法
listener.onFinish(response.toString());
}
} catch (Exception e) {
if (listener != null) {
// 回調onError()方法
listener.onError(e);
}
} finally {
if (connection != null) {
connection.disconnect();
}
}
}
}).start();
}
}
方法二：
- 定義個接口，里面寫上想要對外提供的方法，然后接口寫get、set方法（注意是接口,其實有set方法就行了），聲明出來在邏輯層代碼的方法里，在需要的時候調用接口的方法
- 用的時候先把邏輯層new出來，然后調用邏輯層.set接口（new 邏輯層.接口）{接口的方法}，相當於內部類的用法
實例1：
public class MyQueryHandler extends AsyncQueryHandler{
...
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
...
if(cookie!=null && cookie instanceof CursorAdapter){
CursorAdapter adapter = (CursorAdapter) cookie;
// 給adapter 設置新的cursor
adapter.changeCursor(cursor);
}
if(cursorChangedListener!=null){
cursorChangedListener.onCursorChanged(token, cookie, cursor);
}
}
public IOnCursorChangedListener getCursorChangedListener() {
return cursorChangedListener;
}
public void setOnCursorChangedListener(IOnCursorChangedListener cursorChangedListener) {
this.cursorChangedListener = cursorChangedListener;
}
private IOnCursorChangedListener cursorChangedListener;
/**
* 聲明，cursor改變時的監聽接口
* @author Administrator
*
*/
public interface IOnCursorChangedListener{
void onCursorChanged(int token, Object cookie, Cursor cursor);
}
}
。。。。
//回調接口寫法：這樣就把adapter有回傳回來了
MyQueryHandler myQueryHandler = new MyQueryHandler(getContentResolver());
myQueryHandler.setOnCursorChangedListener(new MyQueryHandler.IOnCursorChangedListener() {
@Override
/**
* 當adapter 獲得 cursor 的時候，回調此方法
*/
public void onCursorChanged(int token, Object cookie, Cursor cursor) {
// 讓listview 顯示最后一行
listView.setSelection(adapter.getCount()-1);
}
});
實例2：
private GestureDetector gestureDetector;
private OnDeleteListener listener;
public void setOnDeleteListener(OnDeleteListener l) {
listener = l;
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
float velocityY) {
deleteButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
itemLayout.removeView(deleteButton);
deleteButton = null;
isDeleteShown = false;
listener.onDelete(selectedItem);
}
});
public interface OnDeleteListener {
void onDelete(int index);
}
下面的內容來自網絡
來源： <http://blog.csdn.net/eclipsexys/article/details/22729289>
java的接口回調，在android下用的是越來越多了，到底該怎么理解他呢？
回調就是外部設置一個方法給一個對象, 這個對象可以執行外部設置的方法, 通常這個方法是定義在接口中的抽象方法, 外部設置的時候直接設置這個接口對象即可.
如何定義一個回調
a. 定義接口 : 在類中定義一個Interface, 並在接口中定義一個抽象方法;
b. 接口對象 : 在類中定義一個該接口的成員變量;
c. 設置對象 : 在類中定義一個公共的方法, 可以設置這個接口的對象, 調用該方法給接口對象成員變量賦值;
d. 調用方法 : 在合適的位置調用接口對象中的方法;
a. 定義接口 : 在類中定義一個Interface, 並在接口中定義一個抽象方法;
b. 接口對象 : 在類中定義一個該接口的成員變量;
c. 設置對象 : 在類中定義一個公共的方法, 可以設置這個接口的對象, 調用該方法給接口對象成員變量賦值;
d. 調用方法 : 在合適的位置調用接口對象中的方法;
好比是一個領導和一個下屬，還有一個下屬間諜三個人之間不清不楚的關系
1、下屬有一個吃飯的事情……
（定義接口）
2、領導發表申明，說對下屬的吃飯這件事感興趣，並說了如果下屬吃飯，他就怎么樣怎么樣，但是老板就是老板，總不能一直盯着下屬所以……
（實現接口，並實現處理監聽事件的方法）
3、領導一說話，間諜就去了下屬那，並且領導給了間諜特權，可以使用我的怎么樣怎么樣方法
（建立於接口的連接，實際上是一個向上轉型的過程，把間諜upcase為一個領導，從而調用領導的方法）
4、，然后只要一吃飯，間諜就通知領導，並替領導完成什么樣什么樣的事情
（通過接口的實例，調用接口中的方法）
這樣一說，大家應該對接口回調的機制有了點感性的理解了吧。
interface People{
void peopleList();
}
class Student implements People{
public void peopleList(){
System.out.println("I’m a student.")；
}
}
class Teacher implements People{
public void peopleList(){
System.out.println("I’m a teacher.");
}
}
public class Example{
public static void main(String args[]){
People a; //聲明接口變量
a=new Student(); //實例化，接口變量中存放對象的引用
a.peopleList(); //接口回調
a=new Teacher(); //實例化，接口變量中存放對象的引用
a.peopleList(); //接口回調
}
}
通過接口，我們將大量共通但實現細節不同的方法抽象出來，再去實現它的接口類中具體處理，這樣通過接口去調用方法的時候，就不用考慮具體調用哪個方法了。
這是一種用法，大致是多態的意思，還有一種用法就是組件中的通信：
例如Fragment間的通信
1、在Fragment中定義接口，申明接口的實例，在onAttach（）方法中實現接口實例化為Activity對象
2、在Fragment中的某個方法內，使用接口的實例，調用Activity的方法，向Activity通信
3、Activity實現接口與結構內的方法，實現處理回調的邏輯