@weidong 2017-07-09T02:45:00.000000Z 字数 6993 阅读 355

接口回调

未分类

摘抄

http://www.jianshu.com/p/c3da97948cd0
http://www.jianshu.com/p/345e36572e66
http://www.mobile-open.com/2016/980232.html

接口回调是指

解释一：

可以把使用实现了某一接口的类创建的对象的引用，赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。

解释二：

接口回调就是指: 可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。简单来说就是A(主线程)很忙没工夫去做一些无聊的——>这时候来了个B(子线程),B说:老大你这么忙,技术活你来 CV这种活就我来吧! 这时候A和B就开始疯狂输出了.但是A又想知道B到底搞定了没有.咋办? 这时候电话C(接口类)来了,当B做完了体力活就拿起电话C开始跟A发了个短信告诉A我搞定了 .然后A就知道B搞定了开始疯狂输出下一个技术活.好了,话不多说开始撸代码.

解释三

理解一个东西，必须从它的本源入手，再实例化到生活事例中，加深理解，毕竟程序是对现实生活的一种抽象。
而android中的回调，遵循的基本思想是Java中的回调函数。
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

Java 中没有指针的概念，通过接口和内部类的方式实现回调的功能:
1. 定义接口 Callback ,包含回调方法 callback()
2. 在一个类Caller 中声明一个Callback接口对象 mCallback
3. 在程序中赋予 Caller对象的接口成员(mCallback) 一个内部类对象如
new Callback（）{
callback（）{
//函数的具体实现
}
这样,在需要的时候,可用Caller对象的mCallback接口成员调用callback()方法,完成回调.

---我---是---华---丽---的---分---割---线---

其实接口回调根本就是：对象方法的调用

在一个函数中调用另外一个函数就是回调
让别人(系统、其它代码)调用我们的方法

以下例子为巩固代码
上例子1：
简单对象方法调用

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        CallBackDemo callBackDemo = new CallBackDemo();
        callBackDemo.show();
    }
    class CallBackDemo{
        public void show(){
            Toast.makeText(MainActivity.this, "哈哈哈", Toast.LENGTH_SHORT).show();
        }
    }
}

例子2：
让别人调用我们方法，类分开了

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ShowLog callBackDemo = new ShowLog();
        //让别人调我们的方法
        CallBackUtils.testCallBack(callBackDemo);
    }
}
public class CallBackUtils {
    public static void testCallBack(ShowLog showToast) {
        showToast.show();
    }
}
class ShowLog {
    private static final String TAG = "ShowLog";
    public void show() {
        Log.e(TAG, "show: 显示日志信息啦");
    }
}

例子3：
可以重写方法

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ShowLog callBackDemo = new ShowLog(){
            @Override
            public void show() {
                Log.e(TAG, "show: 重写方法，实现自己独有的打印");
            }
        };
        //让别人调我们的方法
        CallBackUtils.testCallBack(callBackDemo);
    }
}
public class CallBackUtils {
    public static void testCallBack(ShowLog showToast) {
        showToast.show();
    }
}
class ShowLog {
    private static final String TAG = "ShowLog";
    public void show() {
        Log.e(TAG, "show: 显示日志信息啦");
    }
}

例子4：
如果确定每个人都有自己特有的输出方式，那么可以使用接口来编写ShowLog类，代码就变成

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //基于接口的特性，此时创建ShowLog对象就必须实现show()方法了
        ShowLog callBackDemo = new ShowLog(){
            @Override
            public void show() {
                Log.e(TAG, "show: 重写方法，实现自己独有的打印");
            }
        };
        //让别人调我们的方法
        CallBackUtils.testCallBack(callBackDemo);
    }
}
public interface ShowLog {
    public void show();
}
public class CallBackUtils {
    public static void testCallBack(ShowLog showToast) {
        showToast.show();
    }
}

我

是

阻

挡

线

亲，例子4用到了接口回到，你感受到了吗？

不就是将普通类换成接口而已吗？
不就是利用了接口的特性，必须实现接口的方法而已吗？

来来来，我们模拟一个多人开发环境，学学接口回调的使用场景

公司有两个员工 A（美女）、B（屌丝男）

A 负责写界面的代码
B 负责写网络获取数据的代码

项目代码不多时，A和B各自写了一个方法，B的方法执行完（相当于网络请求完）就会调用A的方法，A就可以乐呵乐呵写界面啦

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        try {
            request();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //A 编写的方法
    public void request() throws InterruptedException {
        //模拟网络请求啦
        Thread.sleep(1000);
        //请求到数据展示啦
        onNetSucceed("我是结果");
    }
    //B 编写的方法，这里显示请求结果数据
    public void onNetSucceed(String result){
    }
}

随着需求的变动，项目的需求越来越多，需要在请求网络数据（调用methodsB()方法之前）给出提示，机智的B怎么可能会错过装逼的会呢，想了一天一夜，就对代码做了如下修改

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        try {
            onNetStart();
            request();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //我是网络请求之前调用，可以显示弹出框等。
    public void onNetStart(){
    }
    //A 编写的方法
    public void request() throws InterruptedException {
        //模拟网络请求啦
        Thread.sleep(1000);
        //请求到数据展示啦
        onNetSucceed("我是结果");
    }
    //B 编写的方法，这里显示请求结果数据
    public void onNetSucceed(String result){
    }
}

又随着需求的变动，发现网络不好的情况下，应用就没有办法提示错误的信息了，本来B想趁此机会和A好好讨论一番，但是A红着脸说，上次不就是你改的吗？然后没有然后了，B又想了一夜

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        try {
            onNetStart();
            request();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //我是网络请求之前调用，可以显示弹出框等。
    public void onNetStart(){
    }
    //A 编写的方法
    public void request() throws InterruptedException {
        //模拟网络请求啦
        Thread.sleep(1000);
        boolean isError = true;//模拟错误和正确
        if(isError){
            onNetSucceed("我是结果");
        }else{
            onNetFailure("我错误啦");
        }
    }
    //B 编写的方法，这里显示正确数据
    public void onNetSucceed(String result){
    }
    //B 编写的方法，这里显示网络请求错误
    public void onNetFailure(String result){
    }
}

还是随着需求的变动，MainActivity里面的代码越来越点多，导致开发越来越困难，B想出了一个方法，将代码分成两个类，网络请求的代码放到名为HttpUtils的类中，B还是想借此机会好好和A讨论加班一番，最重要的是可以和A独处，为此还特意去买了份狗肉火锅，想和A边加班边吃，得知有狗肉吃的A很是开心，眼冒金星问B："我可能要吃两人份，可不可以啦啦啦啦啦啦啦啦啦，巴拉巴拉巴拉"

B：行！（能够和你独处，你吃了我都行）

后

来

A和她男朋友绣着恩爱，吃着狗肉，看着饿着的单身狗加班一个晚上。

虽然B收到了几吨伤害，当是代码还是要写的

因为HttpUtils类的methodsB_1() 需要调用MainActivity的methodsA_1()、methodsA_3()方法，所以将MainActivity对象传给methodsB_1()方法

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        try {
            HttpUtils httpUtils = new HttpUtils();
            httpUtils.request(this);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //我是网络请求之前调用，可以显示弹出框等。
    public void onNetStart(){
    }
    //B 编写的方法，这里显示正确数据
    public void onNetSucceed(String result){
    }
    //B 编写的方法，这里显示网络请求错误
    public void onNetFailure(String result){
    }
}
public class HttpUtils {
    //A 编写的方法
    public void request(MainActivity mainActivity) throws InterruptedException {
        onNetStart();
        //模拟网络请求啦
        Thread.sleep(1000);
        boolean isError = true;//模拟错误和正确
        if(isError){
            mainActivity.onNetSucceed("我是结果");
        }else{
            mainActivity.onNetFailure("我错误啦");
        }
    }
}

当是这样完美了吗？

使用回调写法

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        HttpUtils httpUtils = new HttpUtils();
        httpUtils.request(new HttpUtils.NetCallback() {
            @Override
            public void onNetStart() {
            }
            @Override
            public void onNetSucceed() {
            }
            @Override
            public void onNetFailure() {
            }
        });
    }
}
public class HttpUtils {
    //A 编写的方法
    public void request(NetCallback netCallback) {
        netCallback.onNetStart();
        //模拟网络请求啦
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        boolean isError = true;//模拟错误和正确
        if (isError) {
            netCallback.onNetSucceed();
        } else {
            netCallback.onNetFailure();
        }
    }
    //网络请求状态的回调
    interface NetCallback {
        void onNetStart();//请求开始
        void onNetSucceed();//请求成功
        void onNetFailure();//请求失败
    }
}