java基础之回调机制

参考文献：http://blog.csdn.net/xiaanming/article/details/8703708/

http://www.cnblogs.com/vtianyun/archive/2012/06/19/2555427.html

这两篇文章都写得很好，我也开始也不是太懂回调机制。但是时常在开发过中用到很多

但是都没有懂其中的原理！

这是一个非常经典的例子：

 

有一天小王遇到一个很难的问题，问题是“1 + 1 = ?。

就打电话问小李，小李一下子也不知道，

就跟小王说，等我办完手上的事情，就去想想答案，

小王也不会傻傻的拿着电话去等小李的答案吧，

于是小王就对小李说，我还要去逛街，你知道了答案就打我电话告诉我，

于是挂了电话，自己办自己的事情，过了一个小时，

小李打了小王的电话，告诉他答案是2

下面是我简单的整理一些关于回调机制

1.首先定义一个借口，并给出一个抽象方法

如：

public interface Callback
{
    /**
     * 定义一个回调函数
     * 
     * @param result
     */
    public void solve(String result);
}

2.之后在一个类中实现（implements）一个借口，并且实现其中的抽象方法
 

 如：

public class Wang implements Callback
{

    /**
     * 实现里面的方法
     */
    public void solve(String result)
    {
        System.out.println("小李告诉小王的答案是--->" + result); 
    }

    private Li mLi;

    public Wang(Li li)
    {
        this.mLi = li;
    }

    public void askQuestion(final String question)
    {
        // 这里用一个线程就是异步，
        new Thread(new Runnable()
        {
            public void run()
            {
                /**
                 * 小王调用小李中的方法，在这里注册回调接口 这就相当于A类调用B的方法C
                 */
                mLi.executeMessage(Wang.this, question);
            }
        }).start();
        play();
    }

    public void play()
    {
        System.out.println("我要逛街去了");
    }

}

 

 注意:接口中的方法都是抽象方法

3.其实上面的代码已经实现了，就是注册回调借口，简单的理解为：我要告诉Li这个类，我要做什么。

4.Li这个类处将自己的答案处理完毕之后，调用回调中的抽象方法！这时候，因为Wang类，因为实现了其抽象方法，所以就会得到Li返回的答案！

 

 

下面是完整代码：

public interface Callback
{
    /**
     * 定义一个回调函数
     * 
     * @param result
     */
    public void solve(String result);
}

public class CallbackTest
{
    public static void main(String[] args)
    {
        /**
         * new 一个小李
         */
        Li li = new Li();

        /**
         * new 一个小王
         */
        Wang wang = new Wang(li);

        /**
         * 小王问小李问题
         */
        wang.askQuestion("1 + 1 = ?");
    }
}

public class Li
{
    /**
     * 相当于B类有参数为CallBack callBack的f()---->背景三
     * 
     * @param callBack
     * @param question
     *            小王问的问题
     */
    public void executeMessage(Callback callBack, String question)
    {
        System.out.println("小王问的问题--->" + question);

        // 模拟小李办自己的事情需要很长时间
        for (int i = 0; i < 100; i++)
        {

        }

        /**
         * 小李办完自己的事情之后想到了答案是2
         */
        String result = "答案是2";

        /**
         * 于是就打电话告诉小王，调用小王中的方法 这就相当于B类反过来调用A的方法D
         */
        callBack.solve(result);

    }
}

public class Wang implements Callback
{

    /**
     * 实现里面的方法
     */
    public void solve(String result)
    {
        System.out.println("小李告诉小王的答案是--->" + result); 
    }

    private Li mLi;

    public Wang(Li li)
    {
        this.mLi = li;
    }

    public void askQuestion(final String question)
    {
        // 这里用一个线程就是异步，
        new Thread(new Runnable()
        {
            public void run()
            {
                /**
                 * 小王调用小李中的方法，在这里注册回调接口 这就相当于A类调用B的方法C
                 */
                mLi.executeMessage(Wang.this, question);
            }
        }).start();
        play();
    }

    public void play()
    {
        System.out.println("我要逛街去了");
    }

}

以上仅仅是我个人暂时的理解。