Android 接口回调实例

回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

接口回调的简单解释就是：比如我这个类实现了一个接口里的方法 doSomething，然后注册到你这里，然后我就去做别的事情去了， 你在某个触发的时机回头来调用我 doSomething 的方法。

通过上面的解释，定义接口回调一般分为如下几步:
1. 声明回调函数的统一接口interface A，包含方法fuc();
2. 在调用类caller内将该接口设置为私有成员private A XXX;
3. 在caller内提供一个public方法，可以将外部“该接口A的实现类的引用”通过形参传给XXX；
4. caller的某个方法call()中会用到XXX.fuc()方法;

简单实例

• 在类中定义一个Interface, 并在接口中定义一个抽象方法

public interface  ShowCallBack{
        void onShown();
    }

• 在类中定义一个该接口的成员变量

private ShowCallBack mShowCallBack;

• 在类中定义一个公共方法，可以设置这个接口的对象，调用该方法给接口对象变量赋值

public void setShowCallBack(ShowCallBack c){
        mShowCallBack = c;
    }

• 在合适的时机调用接口对象中的方法

public void onResume() {
        super.onResume();
        if (mShowCallBack != null) {
            mShowCallBack.onShown();
        }
    }

• 注册接口回调

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        FragmentManager manager = getFragmentManager();
        FragmentTransaction tr = manager.beginTransaction();
        if (mTalkingFragment == null) {
            mTalkingFragment = new TalkingFragment();
            /**
             * 实现一个接口实例，实现具体的回调方法，并注册给调用方，
             */
            mTalkingFragment.setShowCallBack(new TalkingFragment.ShowCallBack() {
                @Override
                public void onShown() {
                    Log.d(TAG, "onShown: ok !!!!!!!!!!!!!!!!!");
                }
            });
        }
        if (!mTalkingFragment.isAdded())
            tr.add(R.id.main_content, mTalkingFragment);
        tr.show(mTalkingFragment);
        tr.commit();
    }

完整代码

public class TalkingFragment extends BaseFragment {

    /**
     * 2.申明一个接口对象
     */
    private ShowCallBack mShowCallBack;

    /**
     * 1. 定义一个接口，以便程序员B根据我的定义编写程序实现接口。
     */
    public interface  ShowCallBack{
        void onShown();
    }

    /**
     * 3. 对接口对象赋值，参数为实现了接口的实例
     * 调用实现了接口的实例的方法就完成了回调
     * @param c
     */
    public void setShowCallBack(ShowCallBack c){
        mShowCallBack = c;
    }
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return super.onCreateView(inflater, container, savedInstanceState);
    }
    /**
     * 4. 在合适的时机，调用回调函数
     * @param c
     */
    @Override
    public void onResume() {
        super.onResume();
        if (mShowCallBack != null) {
            mShowCallBack.onShown();
        }
    }
}

在代码中：
1. TalkingFragment 定义了回调接口 ShowCallBack，并持有 ShowCallBack 的引用，同时向外部提供对变量赋值的方法 setShowCallBack ;
2. MainActivity 通过 TalkingFragment 的实例，调用 setShowCallBack(ShowCallBack c) 向 TalkingFragment 注册回调接口 ;
3. TalkingFragment 在合适的时机 (onResume),调用回调接口，通知 MainActivity 我已启动，在接口实现中打印log。

在现实生活中也有类似的例子：
某天，我打电话向你请教问题，当然是个难题，你一时想不出解决方法，我又不能拿着电话在那里傻等，于是我们约定：等你想出办法后打手机通知我，这样，我就挂掉电话办其它事情去了。过了XX分钟，我的手机响了，你兴高采烈的说问题已经搞定，应该如此这般处理。故事到此结束。这个例子说明了“异步+回调”的编程模式。其中，你后来打手机告诉我结果便是一个“回调”过程；我的手机号码必须在以前告诉你，这便是注册回调函数；我的手机号码应该有效并且手机能够接收到你的呼叫，这是回调函数必须符合接口规范。
而在程序代码中，则可以抽象成以下这张图的形式：

C 不会自己调用 b，C 提供 b 的目的就是让 S 来调用它，而且 C 不得不提供。S 并不知道 C 提供的b是什么，因此 S 会约定 b 的接口规范(函数原型)，然后由 C 提前通过S的一个函数 r 告诉 S 自己将要使用 b 函数(即注册)，比如注册监听器就是其中一种典型。其中r为注册函数。
对上图的一个完善是这样的：