一句话总结Java的接口回调机制

一句话总结Java的接口回调机制

直接上干货，一个类持有一个接口对象以及该接口的实现类实例，就可以通过这个接口回调该实现类中的具体方法。

具体步骤：类B回调类A的方法

1. 声明一个接口，接口里面声明相应的方法与参数；
2. 类A实现这个接口，重写方法的具体实现；
3. 类B中声明接口对象，通过set方法或者构造方法等持有类A的实例a(向上转型为接口对象完成初始化);
4. 在类B需要的地方，通过接口对象，回调类A相应的方法。

原理分析：

因为类A实现了这个接口，必须重写相关的方法，在此方法中完成具体进的操作，而类B中，持有类A的实例，因此可以调用接口的方法，当执行到这行代码的时候，就调用了类A中具体的操作，完成了方法的回调。

示例代码

声明接口对象以及方法：

package com.csdn.lhy;

/**
 * @author linghuanyun
 *
 * 下午9:28:23
 */
public interface ICoding {

    public void code(String str);

    public void writeBlog(String title);
}

定义了类Lhy，实现了接口，并完成了方法的具体实现逻辑；

package com.csdn.lhy;

/**
 * @author linghuanyun
 *
 * 下午9:27:56
 */
public class Lhy implements ICoding{

    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Lhy(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public void code(String str) {
        System.out.println("灵幻云会的语言： "+str);
    }
    @Override
    public void writeBlog(String title) {
        System.out.println("灵幻云正在写博客,标题是： "+title);
    }


}

定义了类CSDN，持有了接口对象，并提供入口方法(这里是构造方法)用来传入Lhy的实例；

package com.csdn.lhy;

/**
 * @author linghuanyun
 *
 * 下午9:29:56
 */
public class CSDN {
    private ICoding callback;

    public CSDN(ICoding callback) {
        super();
        this.callback = callback;
    } 

    public void chooseLanguage(){
        callback.code("Java");
    }
    public void checkTitle(String title){
        System.out.println("耗时操作进行中.....");
        try {
            Thread.sleep(3000);
            callback.writeBlog(title);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

测试类如下，在构造方法中传入Lhy的实例，回调相应的方法。
另一种方式是直接通过匿名内部类的方式来写，代码如下。

package com.csdn.lhy;

import java.awt.SystemColor;

/**
 * @author linghuanyun
 *
 *         下午9:30:15
 */
public class ICodingTest {

    public static void main(String[] args) {

//       CSDN csdn = new CSDN(new Lhy("lhy", 18));
//       csdn.chooseLanguage();
//       csdn.checkTitle("一句话总结Java回调机制");

        CSDN csdn = new CSDN(new ICoding() {

            @Override
            public void writeBlog(String title) {
                try {
                    Thread.sleep(3000);
                    System.out.println("灵幻云写完了博客,标题是： " + title);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            @Override
            public void code(String str) {

                System.out.println("灵幻云会的语言： " + str);
            }
        });

        csdn.chooseLanguage();
        csdn.checkTitle("一句话总结Java回调机制");

    }
}

运行结果如下：

结束语：

接口使Java摆脱了单继承的局限性，也通过抽象的方式，提高了代码的复用性，在耦合度比较高的2个类中，通过接口来完成之间的联系，当遇到业务逻辑改动的时候，修改中间层的接口就可以，而不需要对代码进行大量的重构。

并且接口回调在一定程度上解决了Java中异步任务场景，通过设定了回调方法的入口，而回调相应的方法完成业务逻辑，在处理异步的场景中经常用到。

在Android中，接口以及接口回调也有着相当高的出场率，比如监听的实现，Fragment与Activity之间的数据传输等等，希望本篇文章可以解决大家对于接口回调的一些疑惑。