接口回调的概念和典型例程（java和kotlin）

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

文章目录

前言
一、什么是接口回调？
二、为什么要使用接口回调
三、在JAVA和kotlin中几个接口回调的实例
- 1.java实例
- 2.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() 方法进行测试。当结果成功时，输出成功回调的结果；当结果错误时，输出错误回调的结果。