Android中的回调

先来看一个简单的例子：
有两个类 ClassA ，和 ClassB， ClassA调用ClassB里面的方法，

?

public class ClassB{
    public void method_from_classB(){
        for(int i=0;i<10;i++){
            System.out.print("..."+i);
        }
    }
}
public class ClassA{
    public static void main(String args[]){
        classB clasB=new ClassB();
        classB.method_from_classB();
    }
}

输出：

...0...1...2...3...4...5...6...7...8...9

卧槽，哪个傻逼写的博文，侮辱我的智商不是吗，嘻嘻，是为了做比较，接下来看看利用回调， ClassA 是怎么调用 ClassB中的 方法的，注意是回调：

让ClassB 实现 ClassA定义的接口

?

public class ClassB implements ClassA.ClassAInterface{
    public ClassB(){
        new ClassA().RegisterInterface(this);
        System.out.print("...ClassB..."+this);
    }
    @Override
    public void method_from_interface(){
        for (int i=0;i<10;i++){
            System.out.print("..."+i);
        }
    }
}

ClassA里面定义接口和抽象方法：

?

public class ClassA{
    public static ChatAdapter.ClassAInfterface classAInfterface;
    public interface ClassAInterface{
        public void method_from_interface();
    }
    public void RegisterInterface(ClassAInterface a_interface){
        this.classAInfterface=a_interface;
        System.out.print("...a_interface..."+a_interface);
    }
    public static void main(String args[]){
        ClassB classB=new ClassB();//标记@1，后面做解释
        System.out.print("...classAInterface..."+classAInterface);
        if(classAInfterface!=null){
            classAInfterface.method_from_interface();
        }
    }
}

输出：

...0...1...2...3...4...5...6...7...8...9

整理下，也就是 我在ClassA里面定义了一个接口（interface），接口里面又定义了一个方法，但没有方法体，也就不做任何事情。 

当 ClassA 执行到 mian（） 函数时，就会调用接口的方法，但前面讲了，接口的方法没有实现具体的事情，它就会找到 ClassB 里面对应的 方法，来实现具体的事情。

呦呦呦，ClassA 的接口的方法是怎么找到 ClassB 的方法，难道会上天？？？

也就是下面分析这句代码是怎么上天的：

// 利用接口的回调实现 ClassB中 的方法的 具体事情

 classAInterface.method_from_interface();

我在上面的代码中用 System.out.println 打印出了日志做分析：

第一个（ClassA中的方法）：

?

public void RegisterInterface(ClassAInterface a_interface){
        this.classAInfterface=a_interface;
        System.out.print("...a_interface..."+a_interface);
    }

输出：

...a_interface...ClassB@3ddb8962

第二个：

?

    public ClassB(){
        new ClassA().RegisterInterface(this);
        System.out.print("...ClassB..."+this);
    }

输出：

...ClassB...ClassB@3ddb8962

第三个：

System.out.print("...classAInterface..."+classAInterface);
        if(classAInfterface!=null){
            classAInfterface.method_from_interface();
        }

输出：

...classAInterface...ClassB@3ddb8962

看到这里是不是恍然大悟呢 ，输出都是 “ ClassB@3ddb8962 ” 也就是ClassB 对象的引用！！！

啊！接口只不过是将 ClassB 对象的引用 传到 ClassA中而已，那这句会上天的语句是不是很好解释了呢。

       classAInterface.method_from_interface();

相当于  ClassB@3ddb8962.method_from_interface();

这是不是跟最上面到的代码：

?

1 2	ClassB classB = new ClassB();  classB.method_from_classB();

一样呢，这也是为什么我最开始要举这个例子的原因！！！

相信看到这里应该理解了接口的回调是怎么回事了吧。
但有一点又糊涂了，为什么 要接口回调这么麻烦的，最上面的在ClassA里面执行：

?

1 2	ClassB classB = new ClassB();  classB.method_from_classB();

不是照样可以 ClassA 调用 ClassB 里面的 方法。。。。但要是ClassA 要调用ClassC，ClassD ...，里面的方法呢，是不是还要改变ClassA里面的代码，实例化ClassC,ClassD ... 的对象,显然是不好的，要是使用接口那就不用改变ClassA 里面的代码了，任何类只要实现ClassA 里面的接口就可以.

解释一下 标记@1 ：

上面那段话好像跟 标记@1 违背了，在 ClassA 里面确实也需要实例化 ClassB对象。

因为要 【利用】 初始化的时候执行构造方法里面的代码：

?

1 2 3 4

public ClassB(){      // 相当于回调事件的注册，初学者出现回调空指针很有可能这边忘记‘注册'了      new ClassA().RegisterInterface( this );    }

将this 传递给 ClassA ，作用也就是 上面利用 日志分析的作用。

但再 Android 开发中救你不必这样了，
可以在 Activity 的初始化时执行：

?

1 2 3 4 5 6

@Override    protected void onCreate(Bundle savedInstanceState) {         // 相当于回调事件的注册，初学者出现回调空指针很有可能这边忘记‘注册'了      new ClassA().RegisterInterface( this ); }

在Android 开发中 ClassA 里面的 mian（） 函数可以用事件来代替，触发：
如：

?

1 2 3 4 5 6 7 8 9

button.setOnClickListener( new OnClickListener() {                @Override        public void onClick(View v) {          // TODO 自动生成的方法存根          if (classAInterface != null ){          classAInterface.method_from_interface();        }      });

DEMO例子：

下面用一个Android中应用到"回调"的场景,来进一步解释。

[java]  view plain  copy

 print ?

1. Button button = (Button)this.findViewById(R.id.button);  
2. button.setOnClickListener(new Button.OnClickListener() {  
3.   
4.   //回调函数  
5.   @override  
6.   publicvoid onClick(View v) {  
7.     buttonTextView.setText("按钮被点击了");  
8.   }  
9. });  

这里肯定很熟悉了,给Button设置监听器

这其实就是"回调"最常见的应用场景之一。我们自己不会显示地去调用onClick方法。用户触发了该按钮的点击事件后，它会由Android系统来自动调用。

 

在这里我们用代码,模拟注册事件监听器。
先写一个监听器接口

[java]  view plain  copy

 print ?

1. package com.listener;  
2.   
3. /** 
4.  * 点击监听器接口 
5.  * @author jason0539 
6.  * 
7.  */  
8. public interface MyOnClickListener {  
9.     public void onClick();  
10. }  

然后写一个我们自己的Button类

[java]  view plain  copy

 print ?

1. package com.listener;  
2.   
3. public class MyButton {  
4.     private MyOnClickListener listener;  
5.       
6.     /** 
7.      * 设置具体点击监听器 
8.      * @param listener 点击监听器实现类 
9.      */  
10.     public void setOnClickListener(MyOnClickListener listener) {  
11.         this.listener = listener;  
12.     }  
13.       
14.     /** 
15.      * 按钮被点击 
16.      */  
17.     public void doClick() {  
18.         listener.onClick();  
19.     }  
20. }  

最后模拟Client端的注册监听器和触发点击操作。

[java]  view plain  copy

 print ?

1. package com.listener;  
2.   
3. publicclass Client {  
4.     public static void main(String[] args) {  
5.         MyButton button =new MyButton();  
6.         //注册监听器  
7.         button.setOnClickListener(new MyOnClickListener() {  
8.   
9.             @Override  
10.             public void onClick() {  
11.                 System.out.println("按钮被点击了");  
12.                   
13.             }  
14.               
15.         });  
16.         //模拟用户点击  
17.         button.doClick();  
18.     }  
19. }  

原文地址：http://www.jb51.net/article/90466.htm

相关文章：http://www.jb51.net/article/74194.htm

?