安卓回调机制

写安卓这么久了，对于回调一直没有深入研究。其实所谓的回调函数就是：在A类中定义了一个方法，这个方法中用到了一个接口和该接口中的抽象方法，但是抽象方法没有具体的实现，需要B类去实现，B类实现该方法后，它本身不会去调用该方法，而是传递给A类，供A类去调用，这种机制就称为回调。（参考系统的view的onClick()接口理解）

我的理解：老公要老婆做菜，老婆不知道老公想吃什么菜，那么就在老婆做菜的方法里传入一个做菜的接口，调用一个没实现的抽象方法，当老公让老婆做菜时调用做菜的方法，然后实现做菜接口，老婆的做菜方法里具体实现那个抽象方法，就可以想做什么菜接写什么代码啦，这样就做到了调用者想干什么自己实现的思想了。

其实网文一大推都在说，也不过是互相转载而已，这其中看到几篇比较不错的，这里转载一下。

1-----版权声明：^_^ 尊重原创，共享知识，转载请注明"_程序猿大人_"http://blog.csdn.net/a_running_wolf

什么是自定义回调函数？

        自定义回调函数，顾名思义，就是我们自己定义的回调函数。其实上边那个例子就是自定义回调函数！我们习惯上把别人定义好的回调函数叫作回调函数，Android系统中TextView、ImageView等和它们的子类控件的Onclick事件响应就是典型的回调机制。关于这个这位大虾讲得比我好——详细介绍Android中回调函数机制，详细看看会很有帮助的！

        一个简单的自定义回调函数的例子

        最后在举个简单的有代码的例子，看一下回调函数的运行过程：

        首先，我们定义一个interface：

[java] view plain copy

1. public interface MyInterface {  
2.     void sayYourName();  
3. }  

        接着，我们定义一个类，其中一个方法以接口MyInterface类型的对象作为参数：

[java] view plain copy

1. public class MyClass {  
2.     public MyClass() {  
3.         Log.e("WangJ", "MyClass-constructor");         //标注构造函数  
4.     }  
5.     public void sayYourName(MyInterface myInterface){  
6.         Log.e("WangJ", "MyClass-sayYourName_start");    //标注方法开始  
7.         myInterface.sayYourName();                      //遇到不知道具体实现的时候就用接口的抽象方法  
8.         Log.e("WangJ", "MyClass-sayYourName_finish");   //方法结束  
9.     }  
10. }  

        最后，我们在Activity中调用这个类，创建对象并调用其方法，期间实现接口中抽象方法的具体实现逻辑，供回调使用：

[java] view plain copy

1. public class MainActivity extends Activity {  
2.     @Override  
3.     protected void onCreate(Bundle savedInstanceState) {  
4.         super.onCreate(savedInstanceState);  
5.         setContentView(R.layout.activity_main);  
6.         MyClass myClass = new MyClass();  
7.         myClass.sayYourName(new MyInterface() {                     //实现接口并作为参数传入  
8.             @Override  
9.             public void sayYourName() {  
10.                 Log.e("WangJ", "callBack-interface-implementor");    //具体操作实现  
11.             }  
12.         });  
13.     }  
14. }  

        好了，运行一下（我们这个例子没有任何界面，即默认Activity的界面，看日志）：

        运行的顺序就是我们之前理解的：在B中调用A中的方法，A中方法在运行到接口中抽象方法时返回B中寻找具体实现（这就是回调），回调完成后继续执行下边未完成的步骤。

2----参考http://blog.csdn.net/liushuaikobe/article/details/7934565

用Java写了这么久的程序，一直没有理解什么是回调，在最近的Android开发工作中，一个偶然的需求让我突然就对Java中的回调有了一个理解，遂记录之。

　　首先这个需求是这样的，一个Activity中的有一个View，我需要在不同的触发条件下更换这个View的Layout，我们很容易想到写一个方法，把要更换成的Layout的id传进去，然后为这个View设置一下content。就可以在不同的条件下调用这个函数来设置View的layout了，这不难理解。

　　但是，假设，现在该View的Layout更换成了LayoutA，LayoutA里面有一个ImageView，我要对该ImageView通过代码设置一些属性；然后，另一时刻，该View的Layout换成了LayoutB，LayoutB里面有一个Button，我要对该Button通过代码做一些设置，怎么办？

　　我们可以这样解决：

[java] view plain copy

1. class MyActivity extends Activity {  
2.     View view;  
3.     int currentContentFlag;  
4.     private static final int ViewA = 1; // 标志着当前View显示的内容是ViewA  
5.     private static final int ViewB = 2; // 标志着当前View显示的内容是ViewB  
6.     @Override  
7.     public void onCreate(Bundle savedInstanceState) {  
8.         super.onCreate(savedInstanceState);  
9.         setContentView(R.layout.activity_main);  
10.         // 一些例如对view初始化工作略去  
11.         // 我们在这里设置View的layout的Id为layoutId_A  
12.         currentContentFlag = ViewA; // 修改当前显示内容的flag，告诉这个setViewContent函数里面到底执行setViewA还是setViewB  
13.         setViewContent(R.layout.layoutId_A);  
14.     }  
15.     private void setViewContent(int layoutId) {  
16.         view = LayoutInflater.from(this).inflate(layoutId, null); // 设置View的内容  
17.         switch (currentContentFlag) {  
18.             case ViewA:  
19.                 // 说明当前View的内容是ViewA，在这里用代码对ViewA里面的东西进行具体设置  
20.                 setViewA(view);  
21.                 break;  
22.             case ViewB:  
23.                 // 说明当前View的内容是ViewB，在这里用代码对ViewB里面的东西进行具体设置  
24.                 setViewB(view);  
25.                 break;  
26.             default :  
27.                 break;  
28.         }  
29.     }  
30.     private setViewA(View view) {  
31.     }  
32.     private setViewB(View view) {  
33.     }  
34. }  

　　这样的话，每设置一次View的内容，都要修改当前显示内容的flag，通过维护这个flag变量，来告诉这个setViewContent函数里面到底执行setViewA还是setViewB。

　　这样做可不可行呢？实现肯定也可以实现，但是，我想到了用回调机制来完成这件事。

　　什么是回调呢？回调回调，回去调用。我理解回调，就是，在代码执行的过程中，函数FunA()某一时刻被调用，那么将转去执行FunA()，在FunA执行的时候呢，又反过来去执行原代码里的一些东西。这应该是最浅显的解释了吧。

　　在Java语言里面，我们可以通过interface实现自己的回调，Java里面的interface真的太有用了。则上面的代码可以改为下面的实现：

[java] view plain copy

1. class MyActivity extends Activity {  
2.     View view;  
3.     @Override  
4.     public void onCreate(Bundle savedInstanceState) {  
5.         super.onCreate(savedInstanceState);  
6.         setContentView(R.layout.activity_main);  
7.         // 一些例如对view初始化工作略去  
8.         // 我们在这里设置View的layout的Id为layoutId_A  
9.         currentContentFlag = ViewA;   
10.         setViewContent(R.layout.layoutId_A, new ConfigViewInterface() { // 传进去一个接口，并覆盖里面的方法  
11.             public void setView(View view) {  
12.                 setViewA(view);  
13.             }  
14.         });  
15.     }  
16.     private void setViewContent(int layoutId, ConfigViewInterface configViewInterface) {  
17.         view = LayoutInflater.from(this).inflate(layoutId, null); // 设置View的内容  
18.         configViewInterface.setView(view);  
19.     }  
20.     private setViewA(View view) {  
21.     }  
22.     private setViewB(View view) {  
23.     }  
24.     private interface ConfigViewInterface {  
25.         void setView(View view) ;  
26.     }  
27. }  

　　这样是不是就好多了呢？慢慢理解下上面的代码，多少会对你有帮助的。有时候学知识，就要所练，可能当时不理解某个点，不知什么时候突然就懂了。

　　欢迎拍砖。