java回调函数机制

回调函数最重要的特性就在于它的异步。

请想象这样一种场景：在一个类中，创建另外一个类的实例，并调用那个实例的某个方法，获取返回值并进行操作，这是没有任何问题的。但是有的时候，我们调用另外一个类的方法时，那个方法不能很快的返回结果，在这种情况下，我们只有一直等到它返回结果才能继续进行我们其他的工作。这时候我们就会想，有没有那么一种机制：在你调用另外一个类对象的方法时，不必等侯它返回结果，我们可以直接进行其他的工作，如果那个方法计算完毕要返回结果时，会自动调用你的类中指定的方法显示返回的内容。这种想法真的是太棒了，让我们可以不受某些耗时的方法的限制。在java中，我们称这种机制叫做回调函数机制。

那么说到这里，我们怎么去实现一个回调函数呢？大概流程可以这样来思考：

1. 我们现在正在编写的类是A类，要调用的方法在B类里面。
2. 首先A类要调用B类的方法c，那么A类中要存在B类的对象。
3. 对象调用了B类的方法c，希望c得到结果之后能够调用A类的回调函数d，那么B的对象怎么知道调用方法c的类是哪个类呢？所以方法c中要有一个参数是A类型的A类对象，要把A类对象作为参数传进去。
4. 方法c计算结束之后，要把这个结果发送到A类的回调函数d中去。那么问题来了，方法c怎么知道A类中的这么多方法，哪个才是它要回调的d呢？在c++中，我们只要在刚刚传参数的时候，再多传一个d方法的指针就好，但是java并不支持指针操作。java解决的方法是：创建一个接口，这个接口中有且仅有一个函数d，让A类继承这个接口，把第3步A类对象的类型改为这个接口类型，那么c方法中的这个对象只能调用在接口中仅有的这一个方法，这个方法就是我们要的回调函数d。
5. 到现在我们基本完成了回调函数的书写，但是这时并不是异步的，我们将A类中调用方法c放在一个新的线程里。

从前到后，我们总结出这五个步骤，我们现在脑海中已经有了回调函数的构建方法，下面用代码来实现一下回调函数。

CallBackInterface接口：

package CallBack;

/**
 * 
 * @author QuinnNorris
 * 
 */
public interface CallBackInterface {
    // 谁需要拥有一个回调函数，就让他来实现这个接口

    public void ImCallBack(String result);
    // 接口中的唯一方法，这个方法就是我们要的回调函数
}

A类：

package CallBack;

/**
 * 
 * @author QuinnNorris
 * 
 */
public class A implements CallBackInterface {

    public static void main(String args[]) {

        // 我们先创建一个新的线程来进行这个操作，保证我们在回调函数的时候不会干扰到主程序
        new Thread(new Runnable() {
            public void run() {
                A a = new A();
                a.function();
            }
        }).start();
    }

    public void function() {
        B b = new B();
        // 创建B类的一个对象

        String Wyn = "what is your name.";
        System.out.println(Wyn);

        b.c(this, Wyn);
        // 调用c方法，传入A类的对象，和我们要处理的数据
    }

    /**
     * 重写我们实现接口的方法，这个方法就是回调函数。
     */
    @Override
    public void ImCallBack(String result) {
        // TODO Auto-generated method stub

        System.out.println(result);
        // result就是从c方法中传过来的数据
    }
}

B类：

package CallBack;

/**
 * 
 * @author QuinnNorris
 * 
 */
public class B {

    public void c(CallBackInterface a, String str) {
        String myNameIs = "Xiao Zhang";

        a.ImCallBack(myNameIs);
        // 调用回调函数，因为a是CallBackInterface类型，所以我们这里唯一可以调用的就是这个接口中的回调函数
    }

}

这样我们就完成了回调函数的构建，但是在我们日常的工作中，为每个需要回调函数的类都实现一个接口是很不明智的。因为一旦你的代码过长，回调函数需要的接口很可能已经罗列了一大堆。为了解决这种问题，我们可以用匿名内部类的方式来构造回调函数。

首先看一个Android的例子，很经典，很简单：

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.first_layout);

        Button button1 = (Button) findViewById(R.id.button_1);

        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //在这里工作
            }
        });
    }

这个就是使用了匿名内部类来做回调函数的一个典型例子。

下面的这个类是改进之后的A类，这个类不用在类上声明实现了接口，而是在需要那个参数的时候直接new。具体的内部类的情况可以戳这里：内部类

package CallBack;

/**
 * 
 * @author QuinnNorris
 *
 */
public class InnerA {

    public static void main(String args[]) {

        // 我们先创建一个新的线程来进行这个操作，保证我们在回调函数的时候不会干扰到主程序
        new Thread(new Runnable() {
            public void run() {
                A a = new A();
                a.function();
            }
        }).start();
    }

    public void function() {
        B b = new B();
        // 创建B类的一个对象

        String Wyn = "what is your name.";
        System.out.println(Wyn);

        b.c(new CallBackInterface() {

            @Override
            public void ImCallBack(String result) {
                // TODO Auto-generated method stub
                System.out.println(result);
            }
        }, Wyn);
        // 调用c方法，传入A类的对象，和我们要处理的数据
    }


}