无法理解如何在 Kotlin 中使用 SAM 接口

Question

我不明白为什么以下代码有效： 山姆接口：

    fun interface WebResponseHandler
{
    fun onWebResponseFinished(jsonObject:JSONObject)
}

而实现看起来像：

  val onWebResponseHandler: VolleyHandler.WebResponseHandler = VolleyHandler.WebResponseHandler()
{
    fun onWebResponseFinished(jsonObject: JSONObject) {
        Log.v("da", "dsa")
    }

    fun foo() {
        it.getString("name")
    }
}

foo 函数如何知道it 是什么？毕竟，foo 函数不是 VolleyHandler.WebResponseHandler 接口的一部分，它 仅在接口作为一种方法时才起作用。Function Foo 在没有任何参数的情况下被调用，那么为什么 it 的含义在那里？

此外，如果我在尝试实现接口时从接口声明中省略关键字 fun，则会出现另一个问题：

val onWebResponseHandler: VolleyHandler.WebResponseHandler = VolleyHandler.WebResponseHandler()
{
    fun onWebResponseFinished(jsonObject: JSONObject) {
        Log.v("da", "dsa")
    }

    fun foo() {
        Log.v("something", "something")

    }
}

我收到一个编译错误提示

接口 WebResponseHandler 没有构造函数

这两种情况有什么不同？如果我删除 () 我会收到很多不同的错误，例如：

函数声明必须有名字

我希望有人能弄清楚这里出了什么问题

Answer 1

这不是 Kotlin 的混乱，而是你使用了错误的语法来做你想做的事情。

fun interface 让你做的就是写

val onWebResponseHandler = VolleyHandler.WebResponseHandler {
    jsonObject: JSONObject -> Log.v("da", "dsa")
}

普通界面可以做的就是写

val onWebResponseHandler = object : VolleyHandler.WebResponseHandler() {
    fun onWebResponseFinished(jsonObject: JSONObject) {
        Log.v("da", "dsa")
    }

    fun foo() {
        Log.v("something", "something")

    }
}

您的代码不会做任何这些事情，并且在编译时，不会做任何事情，就像您的意思一样。你写的相当于

val onWebResponseHandler = VolleyHandler.WebResponseHandler() { 
  unusedJsonObject: JSONObject ->
    fun aFunctionWhichIsDefinedAndNeverCalled(jsonObject: JSONObject) {
        Log.v("da", "dsa")
    }

    fun anotherFunctionWhichIsDefinedAndNeverCalled() {
        unusedJsonObject.getString("name")
    }
    // doesn't actually do anything at all when executed
    // just defines functions which aren't ever invoked
}

...编译是因为，因为它是 fun interface，您可以只将 lambda 传递给构造函数，但实际上并没有做任何类似于您期望的事情。

Answer 2

这里有一种不同的解释方式可能会有所帮助。

如果要将接口的实现分配给变量或属性，通常必须使用像这样的匿名类语法。注意object: 和override的使用。

val onWebResponseHandler = object : VolleyHandler.WebResponseHandler {
    override fun onWebResponseFinished(jsonObject: JSONObject) {
        Log.v("da", jsonObject.toString())
    }
}

您还可以在匿名类中定义其他公共函数，但这毫无意义，因为无法访问匿名类的唯一成员，因此在此示例中您将无法调用函数 foo() ：

val onWebResponseHandler = object : VolleyHandler.WebResponseHandler {
    override fun onWebResponseFinished(jsonObject: JSONObject) {
        Log.v("da", jsonObject.toString())
    }

    fun foo() {
        Log.v("something", "something")
    }
}

如果您将接口设为fun interface，则可以使用 lambda 语法来定义像这样的单个函数。这就是 SAM 转换。它将您的 lambda 视为您接口的匿名实现。

val onWebResponseHandler = VolleyHandler.WebResponseHandler { jsonObject ->
    Log.v("da", jsonObject.toString())
}

另外，如果一个lambda只有一个参数，你可以省略定义参数名，直接调用it，这样就相当于上面的：

val onWebResponseHandler = VolleyHandler.WebResponseHandler {
    Log.v("da", it.toString())
}

另外，请注意，您可以在代码中的任何位置定义函数，包括在另一个函数的中间。例如：

fun bar() {
    
    fun foo() {
        Log.i("foo", "foo")
    }

    foo()
}

等价于

fun bar() {
    
    val foo: () -> Unit = {
        Log.i("foo", "foo")
    }

    foo() // or foo.invoke()
}

因此，在您的原始代码中，您将这些概念结合起来创建了一个 lambda 函数，其中定义了其他从未使用过的函数。混淆可能是因为它看起来类似于我的顶部代码块，我们在其中使用object: 语法定义了一个匿名类。最大的不同是您省略了object: 和override，因此您使用的是 lambda 语法。您的代码相当于：

val onWebResponseHandler = VolleyHandler.WebResponseHandler { jsonObject ->

    val onWebResponseFinished: (JSONObject) -> Unit = {
        Log.v("da", "dsa")
    }

    val foo: () -> Unit = {
        jsonObject.getString("name")
    }

}

没有 lambda 语法（SAM 转换）看起来像

val onWebResponseHandler = object : VolleyHandler.WebResponseHandler {
    override fun onWebResponseFinished(jsonObject: JSONObject) {
        val onWebResponseFinished: (JSONObject) -> Unit = {
            Log.v("da", "dsa")
        }

        val foo: () -> Unit = {
            jsonObject.getString("name")
        }
    }
}