说说安卓回调——CallBack

时间  2019-11-26
标签 说说 callback 栏目 Android 繁體版
原文   原文链接

1、先上结论

回调就是A和B有合做关系，A的某一个环节须要B本身告诉A要怎么作，这就是回调，回调必定有接口）android

2、随处可见的回调

咱们知道回调在安卓里面随处可见，好比，一个按钮的点击事件canvas

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 好比最简单的Button或者TextView的点击事件setOnClickListener，这个就是回调
        findViewById(R.id.mTv).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

            }
        });
        
    }
}

.
.
接下来咱们看一下 setOnClickListener 的源码，再看看备注
人家google说了，这个方法是一个回调，人家是 callback网络

callback 回调.png

回调必定有接口ide

 

回调必定有接口.png

.
.
（基本上各类带setOnClickListener都是回调，各类监听都是回调）工具

看完这个，咱们来简单做证一下咱们的结论。布局

请出结论：this

回调就是A和B有合做关系，A的某一个环节须要B本身告诉A要怎么作，这就是回调（回调必定有接口google

在上面说的小例子中，View就是咱们说的A，而咱们的MainActivity就是咱们说的B（TextView继承自View这个咱们就都知道了），那么咱们点击了B以后咱们想作点什么事这个只有B本身知道，A确定不知道B想干吗，，而后A里面确定会有本身的逻辑来根据B的只是去干活，因此啊，就是——“A的某一个环节须要B本身告诉A要怎么作”
A里面既然有一个有一个能够被回调的方法，那么A里面必定有一个接口。url

3、本身写一个回调试试呗

只要写过自定义控件的，就必定写回调。这个是天然的，本文的意义是为了简单描述对回调的一个理解。设计

其实作回调很好，好比咱们作了一个自定义的进度条，按钮，或者开关等等，咱们都须要作回调接口，有什么好处呢？可让使用咱们控件的人本身去选择一些事情，而不是咱们写接口的吧东西给写死了，咱们能够提供一些方法，让别人本身选择颜色，大小，数值等等。

例子1

咱们假设作了一个自定义的开关按键，而后按下以后就能够改变一下另一个控件的文字。（只为演示，不作开关，省得代码偏长）

点击以后调用者要执行一些逻辑，至于具体执行什么逻辑，一点都不关咱们事，这是使用咱们控件的人本身想干吗就去干嘛。

上代码：

一个简单自定义控件

/**
 * 一个自定义开关按钮(假设)，附带set点击的接口
 * 第一步，定义接口，接口里面有个 设置点击的监听
 * 第二步，在当前类中定义一个接口的变量，以便接受其余类实现接口后传过来的接口
 * 第三步，当当前类中写一个 public的设置接口的方法，参数是咱们写的接口
 * 第四步，在咱们的须要的地方执行其余类要求咱们作的事情
 */
public class DiyToggle extends View {

    private Bitmap mBackground;

    // 第二步，在当前类中定义一个接口的变量，以便接受其余类实现接口后传过来的接口
    private OnToggleClickListener onToggleClickListener;

    public DiyToggle(Context context) {
        super(context);
    }

    public DiyToggle(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public DiyToggle(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }


    public void setBackground(int resId) {
        mBackground = BitmapFactory.decodeResource(getResources(), resId);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int measuredWidth = mBackground.getWidth();
        int measuredHeight = mBackground.getHeight();
        setMeasuredDimension(measuredWidth, measuredHeight);
    }


    @Override
    protected void onDraw(Canvas canvas) {
        // 画背景
        if (mBackground != null) {
            canvas.drawBitmap(mBackground, 0, 0, null);
        }

    }

    // 第三步，当当前类中写一个 public的设置接口的方法，参数是咱们写的接口
    // 这样其余类一旦调用了setToggleClickListener，就必须实现咱们写的接口
    public void setToggleClickListener(OnToggleClickListener onToggleClickListener){
        if(onToggleClickListener != null){
            this.onToggleClickListener = onToggleClickListener;
        }
    }


    // 第一步，定义接口，接口里面有个 设置点击的监听
    interface OnToggleClickListener{
        void onDoClick();
    }


    // 第四步，在咱们的须要的地方执行其余类要求咱们作的事情
    // 这里咱们复写了系统自带的onTouchEvent的up方法，也就是当点击后松开手指时执行
    // 咱们在松开手指后，就调用咱们本身接口的  onDoClick方法，具体作什么，咱们不知道，也不用知道
    // 其余人说，咱们作就好。
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int action = event.getAction();
        if(action==MotionEvent.ACTION_UP){
            onToggleClickListener.onDoClick();
        }
        return true;
    }
}

.
.
布局文件

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"

    tools:context="com.amqr.callbackdemo.MainActivity">

    <com.amqr.callbackdemo.DiyToggle
        android:id="@+id/mTog"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" >
        </com.amqr.callbackdemo.DiyToggle>

    <TextView
        android:id="@+id/mTvCenter"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello"
        android:textSize="30dp"
        android:layout_centerInParent="true"
        />

</RelativeLayout>

.
.
MainActivity

public class MainActivity extends Activity {

    private DiyToggle mTog;
    private TextView mTvCenter;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTog = (DiyToggle) findViewById(R.id.mTog);
        mTvCenter = (TextView) findViewById(R.id.mTvCenter);

        mTog.setBackground(R.mipmap.tog);

        // 调用了DiyToggle的 setToggleClickListener 方法，就得实现 接口
        mTog.setToggleClickListener(new DiyToggle.OnToggleClickListener() {
            @Override
            public void onDoClick() {
                Log.d("Tog","...=================");
                mTvCenter.setText("世界");
            }
        });
    }
}

.
.
gif图

演示.gif

.
.

像上面这样子，就完成了 一个 回调 应用演示。
固然，你也能够说我直接用你的在MainActivity里面用mTog调用setOnClickListener方法不是同样能够上面的功能吗！是的，没错，可是咱们这里不是为了实现功能，而是为了简单描述一下若是定义接口实现回调。
另外，像上面这样是调单的演示，再往上一点点，咱们固然还能够在写接口时在onDoClick里面添加参数，好比写成 void onDoClick(DiyToggle diyToggle,Boolean toggleState); 这样咱们就能够在指定哪个 DiyToggle 变成 哪种开关状态。
.
.

注意

最后干活的仍是DiyToggle，至于为何A最后为何能让文本改变，这就是系统自带onTouchEvent里面有一套复杂的安卓设计在里面，有了它DiyToggle才能作这么多事情。
代码通常都是按照顺序执行的，咱们要要作的，就是把MainActivity的里面实现了接口的mTog交代的事情的，也就是onDoClick这个方法放在DiyToggle合适的位置，这样一旦mTog调用了setToggleClickListener方法，那么mTog交代事情就会被执行。

Paste_Image.png

 

.
.

例子2

咱们如今使用Volley来访问百度，而且把放回的网页代码显示出来。

大概代码是这样子的：

MainAvtivity

public class MainActivity extends Activity {

    private TextView mTvRequest;
    private TextView mTvCode;
    

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTvRequest = (TextView) findViewById(R.id.mTvRequest);
        mTvCode = (TextView) findViewById(R.id.mTvCode);

        mTvRequest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 第一步，利用Volleynew出来一个请求队列
                RequestQueue mQueue = Volley.newRequestQueue(MainActivity.this);

                // 第二步，建立一个请求
                // 在这里，咱们须要关心的就是请求究竟是成功仍是失败。就这两点。
                // 能够利用接口封装起来。
                StringRequest stringRequest = new StringRequest("http://www.baidu.com",
                        new Response.Listener<String>() {
                            @Override
                            public void onResponse(String response) {
                                Toast.makeText(MainActivity.this,"访问成功",Toast.LENGTH_SHORT).show();
                                mTvCode.setText(response);
                            }
                        }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        Toast.makeText(MainActivity.this,"访问失败",Toast.LENGTH_SHORT).show();
                    }
                });

                // 第三步，把请求放进队列
                mQueue.add(stringRequest);
            }
        });
    }
}

.
.
布局文件

布局文件.png
请求百度.gif

效果实现了。根据上面的代码，咱们使用了Volley作了一个请求网络的简单示例。在上面的代码中，咱们看得出来，咱们须要关心的只是请求的成功或者失败的结果，就这两点，那么，这个东西彻底能够封装起来。写一个接口，进行回调。这就是咱们写例子2的目的。

咱们来写一个工具类，叫作VolleyHttpUtils，而后提供一个方法requestNet，这个requestNet方法除了传入必要的url和context以外，还有一个参数是咱们本身定义的接口。

这样外界一旦调用了这个方法就必须实现接口，实现接口以后外界想作什么操做外界本身去决定，最后，在requestNet方法里面真正去执行外界交待给咱们的任务。

逼逼了这么多，仍是直接看代码吧。

public class VolleyHttpUtils {

    // 外界除了传入必要的url和上下文以外，最关键的就是要实现咱们的接口，这样外界就能方便地交待工做给咱们
    // 咱们不能把东西写死，须要让调用者有必定的自由，他具体想干吗让他本身去具体发挥，而后真正工做的仍是咱们本身
    public  static void requestNet(String url,Context context , final OnHttpListener onHttpListener){
        RequestQueue mQueue = Volley.newRequestQueue(context);
        StringRequest stringRequest = new StringRequest(url,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        // 外界实现接口交待的关于请求的成功的代码在此处被真正执行
                        onHttpListener.onResponse(response);

                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                // 外界实现接口交待的关于请求的失败的代码在此处被真正执行
                onHttpListener.onErrorResponse(error);
            }
        });
        mQueue.add(stringRequest);
    }
    interface  OnHttpListener{
        void onResponse(String response);
        void onErrorResponse(VolleyError error);

    }

}

.
.
MainActivity调用方式以下

public class MainActivity extends Activity {

    private TextView mTvRequest;
    private TextView mTvCode;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTvRequest = (TextView) findViewById(R.id.mTvRequest);
        mTvCode = (TextView) findViewById(R.id.mTvCode);

        mTvRequest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                
                String url = "https://www.baidu.com";
                // requestNet方法须要传入3个参数，这里关键是实现接口，而后用户就能够只关心成功和失败的部分
                // 最后把工做扔给requestNet本身去作
                VolleyHttpUtils.requestNet(url, MainActivity.this, new VolleyHttpUtils.OnHttpListener() {
                    @Override
                    public void onResponse(String response) {
                        Toast.makeText(MainActivity.this,"访问成功，使用回调",Toast.LENGTH_SHORT).show();
                        mTvCode.setText(response);
                    }

                    @Override
                    public void onErrorResponse(VolleyError error) {
                        Toast.makeText(MainActivity.this,"访问失败，使用回调",Toast.LENGTH_SHORT).show();
                    }
                });
                
            }
        });
    }
}

看一下gif图片，同样能够实现效果，利用这个简单的demo咱们能够更加理解接口和回调的工做关系了。

请求百度使用回调.gif

例子2的演示至此完成。

结语

回调就是A和B有合做关系，A的某一个环节须要B本身告诉A要怎么作，这就是回调（回调必定有接口）

其实最后的作事情的仍是A，只不过，A不能把事情给说死了，有一些东西，仍是要B说一说。
就好像，A是卖鞋子的，能够整个一条龙生产，B是客户，客户老是有本身的个性的，A就弄了一个接口，（一张设计设计搭配图），B拿了这个设计搭配图，指定了鞋带什么颜色，鞋帽上什么布料，最后工做仍是交给A来作。

本文完。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程