Android 中关于接口回调，监听的一看就懂版本_android 接口回调

Android（Java）中的看一遍就懂的回调，接口监听

一、回调必有的四要素：
1.回调的接口，该接口一般在使用的类里面创建或者单独创建

 //创建的回调接口，以及接口中要做的事
 public interface Callback{
        void doSomething();
    }
1
2
3
4

2.在使用的类中接口的定义变量（接口不可以实例化）

 //    一个接口变量
    private Callback mCallback;
1
2

3.一个给接口变量赋值的方法

//一个给接口变量赋值的方法
    public void setmCallback(Callback callback){
        mCallback=callback;
    }
1
2
3
4

4.该类中定义的接口变量的使用的场景

//一个使用接口变量的地方
    public void use(){
        mCallback.doSomething();
    }
1
2
3
4

整体的代码如下，一般将将接口写在使用的类中

public class  TestA {
     //    一个接口变量
    private Callback mCallback;
    //     一个回调
    public interface Callback{
        void doSomething();
    }
    //一个给接口变量赋值的方法
    public void setmCallback(Callback callback){
        mCallback=callback;
    }
    //一个使用接口变量的地方
    public void use(){
        mCallback.doSomething();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二、具体实现回调的接口的类：
在具体回调实现的类中，一般是实例化使用类的对象，在具体实现的类中采取接口的变量赋值，以及接口的具体实现方法，正式这样综合实现了接口和具体的实现分离，从而达到回调效果,具体也是三大要素

1. 使用接口类实例的引用
2. 引用的对象实现对接口的变量的传递
3. 引用的对象对接口的使用

1.常用的实现的方法是采用匿名的方式实现接口的具体方法

 public class TestB extends Activity {
 	 //TestA类的实例的引用
 	private TestA mTestA
 	 @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);	
        mTestA=new TestA();
         mTestA.setmCallback(new mTestA.Callback() {
            @Override
            public void doSomething() {
            	//具体实现接口的方法
                Log.d(TAG, "doSomething: "+"我是接口的具体实现");
            }
        });
        //实例实现TestA类中使用接口的方法
        mTestA.user();
        }
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.通过实现接口，以及传递自己本身来实现回调

public class B extends Activity implements TestA.Callback {
   


    //A类的实例的引用
    private TestA mTestA;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
	    mTestA=new TestA ();
	    //B类将自己（实际上是接口的实现）传给A类实例的接口变量
	    mTestA.setmCallback(this);
	    //实例实现A的方法，或者在A中实现该方法
	    mTestA.user();
	    }
    //B类实现了A类的接口
    @Override
    public void doSomething() {
        Log.d(TAG, "doSomething: "+"我是接口的具体实现");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

回调的简单例子：
1.接收数据

public class MainActivity extends AppCompatActivity implements MyCallBack {

    private ActivityMainBinding activityMainBinding;
    public static final String TAG="MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        activityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        getData getData=new getData();
        getData.SetCallBack(this);
    }


    @Override
    public void getInfo(String info) {
        Log.e(TAG, "getInfo: "+info );
        activityMainBinding.showinfo.setText(info);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.创建接口

public interface MyCallBack {
    void getInfo(String info);
}
1
2
3

3.获取数据

public class getData {
    public String MyName="我是功夫熊猫";
    private MyCallBack myCallBack;

    public void SetCallBack(MyCallBack myCallBack){
        this.myCallBack =myCallBack;
        showInfo(MyName);
    }

    public void showInfo(String info){
        this.myCallBack.getInfo(info);
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.结果展示

总结如下：

• A类中有一个接口变量和接口。
• B类实现A类的接口（这个接口就是所谓的回调接口）。
• A类的接口变量会（通过过某种方法）获得靠B类实现的接口。
• A类在一个适当的时机“使用”这个接口变量，即调用接口中的函数（这个函数就是所谓的回调函数）。