接口回调的概念和典型例程（java和kotlin）-Toy模板网

这篇具有很好参考价值的文章主要介绍了接口回调的概念和典型例程（java和kotlin）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

`接口回调对于初学者来说是一个不太好理解的概念，笔者也是被折磨了好久都没有完全掌握和理解，但是在程序编写确实常常要用到的。本文通过几个实例来学习和理解接口回调的基本概念。

一、什么是接口回调？

接口回调是指把使用实现了某一接口的类创建的对象的引用，赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。不同的类在使用同一接口时，可能具有不同的功能体现，即接口的方法体不必相同，因此接口回调可能产生不同的行为。

二、为什么要使用接口回调

接口回调的作用主要体现在以下几个方面

解耦：

接口回调使模块间的耦合度降低，便于代码的管理和维护。通过回调，一个模块可以将其功能和行为与其他模块进行分离，减少直接依赖其他模块的特定实现。

异步处理：

接口回调允许在适当的时候进行异步操作。这意味着调用者不需要等待操作完成，可以在继续执行其他任务的同时，等待回调的触发。

事件驱动：

通过接口回调，可以实现事件驱动的编程模型。在这种模型中，特定事件（如用户操作或系统消息）的触发可以激发回调函数，进而引发一系列的函数调用和处理过程。

消息传递：

接口回调可以实现一种形式的消息传递。当一个模块完成某些任务后，它可以触发回调来通知其他模块任务已完成，或者传递相关的数据和状态信息。

三、在JAVA和kotlin中几个接口回调的实例

1.java实例

以下是一个简单的Java示例，演示了接口回调的基本概念：

java
// 定义接口  
interface Callback {  
    void callbackMethod();  
}  
  
// 实现接口的类A  
class ClassA implements Callback {  
    public void callbackMethod() {  
        System.out.println("ClassA's callback method");  
    }  
}  
  
// 实现接口的类B  
class ClassB implements Callback {  
    public void callbackMethod() {  
        System.out.println("ClassB's callback method");  
    }  
}  
  
// 调用接口的类  
class Caller {  
    private Callback callback;  
      
    public Caller(Callback callback) {  
        this.callback = callback;  
    }  
      
    public void doSomething() {  
        // 在某个时刻调用接口回调方法  
        callback.callbackMethod();  
    }  
}  
  
// 测试代码  
public class Main {  
    public static void main(String[] args) {  
        Caller caller = new Caller(new ClassA());  
        caller.doSomething();  // 输出："ClassA's callback method"  
          
        caller = new Caller(new ClassB());  
        caller.doSomething();  // 输出："ClassB's callback method"  
    }  
}

在这个例子中，我们定义了一个接口Callback，它有一个方法callbackMethod()。然后，我们创建了两个类ClassA和ClassB，它们都实现了这个接口，并提供了各自实现的callbackMethod()方法。接下来，我们创建了一个类Caller，它有一个类型为Callback的成员变量，并在其doSomething()方法中调用这个成员变量的callbackMethod()方法。最后，我们在main()方法中分别将ClassA和ClassB的对象作为参数传递给Caller的构造函数，并在调用doSomething()方法时，调用了相应类的callbackMethod()方法。这就是接口回调的基本概念，即通过接口将不同的类联系在一起，并在适当的时候调用它们各自实现的方法。

2.kotlin实例

###2.1使用接口回调实现计算器：

kotlin

interface Calculator {  
    fun add(a: Int, b: Int): Int  
    fun subtract(a: Int, b: Int): Int  
}  
  
class CalculatorImpl: Calculator {  
    override fun add(a: Int, b: Int): Int {  
        return a + b  
    }  
  
    override fun subtract(a: Int, b: Int): Int {  
        return a - b  
    }  
}  
  
fun main() {  
    val calculator: Calculator = CalculatorImpl()  
  
    val result = calculator.add(5, 3)  
    println("5 + 3 = $result")  
  
    val subtractResult = calculator.subtract(10, 4)  
    println("10 - 4 = $subtractResult")  
}

在这个例子中，我们定义了一个接口 Calculator，它包含了两个方法 add 和 subtract，分别用于加法和减法运算。然后，我们创建了一个实现了该接口的类 CalculatorImpl，并提供了相应的实现。在 main() 函数中，我们创建了一个 Calculator 类型的对象 calculator，并将其初始化为 CalculatorImpl()。接下来，我们使用 calculator 对象调用 add 和 subtract 方法，并打印结果。

###2.2使用接口回调实现回调函数：

kotlin

interface Callback {  
    fun onSuccess(result: String)  
    fun onError(error: String)  
}  
  
class MyClass {  
    private val callback: Callback? = null  
  
    fun performAction(callback: Callback) {  
        this.callback = callback  
        // 执行某些操作...  
        if (success) {  
            callback.onSuccess("成功结果")  
        } else {  
            callback.onError("错误结果")  
        }  
    }  
}  
  
class MyCallback: Callback {  
    override fun onSuccess(result: String) {  
        println("成功回调：$result")  
    }  
  
    override fun onError(error: String) {  
        println("错误回调：$error")  
    }  
}  
  
fun main() {  
    val myClass = MyClass()  
    val myCallback = MyCallback()  
    myClass.performAction(myCallback)  
}

在这个例子中，我们定义了一个接口 Callback，它包含了两个方法 onSuccess 和 onError，分别用于处理成功和错误的结果。然后，我们创建了一个类 MyClass，它有一个 callback 属性，用于存储传递进来的回调函数。在 performAction() 方法中，我们执行某些操作，并根据结果调用相应的回调函数。在 MyCallback 类中，我们实现了 Callback 接口，并提供了相应的回调函数实现。最后，在 main() 函数中，我们创建了 MyClass 和 MyCallback 的实例，并调用 performAction() 方法进行测试。当结果成功时，输出成功回调的结果；当结果错误时，输出错误回调的结果。