Java Kotlin：使用 lambda 代替函数式接口？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/33590646/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Kotlin: Use a lambda in place of a functional interface?
提问by Jire
In Java we can do this
Events.handler(Handshake.class, hs -> out.println(hs));
在 Java 中我们可以这样做
Events.handler(Handshake.class, hs -> out.println(hs));
In Kotlin however I am trying to replicate the behavior to replace this:
然而，在 Kotlin 中，我试图复制行为来替换它：
Events.handler(Handshake::class, object : EventHandler<Handshake> {
override fun handle(event: Handshake) {
println(event.sent)
}
})
With a more convenient:
有了更方便的：
Events.handler(Handshake::class, EventHandler<Handshake> { println(it.sent) })
Events.handler(Handshake::class, EventHandler<Handshake> { println(it.sent) })
For some reason in reference to EventHandler:
出于某种原因，参考EventHandler：
More preferably however I'd like to use something even shorter like this:
Events.handler(Handshake::class, { println(it.sent) })
更可取的是，我想使用更短的东西：
Events.handler(Handshake::class, { println(it.sent) })
Or use the advertised feature to use the method like this:
Events.handler(Handshake::class) { println(it.sent) }
或者使用广告功能来使用这样的方法：
Events.handler(Handshake::class) { println(it.sent) }
This is my Eventsobject:
这是我的Events对象：
import java.util.*
import kotlin.reflect.KClass
object Events {
private val map = HashMap<Class<*>, Set<EventHandler<*>>>()
fun <T : Any> handler(eventType: KClass<T>, handler: EventHandler<T>) {
handler(eventType.java, handler)
}
fun <T> handler(eventType: Class<T>, handler: EventHandler<T>) = handlers(eventType).add(handler)
fun post(event: Any) = handlers(event.javaClass).forEach { it.handle(event) }
operator fun plus(event: Any) = post(event)
private fun <T> handlers(eventType: Class<T>): HashSet<EventHandler<T>> {
var set = map[eventType]
if (set == null) {
set = HashSet<EventHandler<*>>()
map.put(eventType, set)
}
return set as HashSet<EventHandler<T>>
}
}
And my EventHandlerinterface:
还有我的EventHandler界面：
@FunctionalInterface
interface EventHandler<T> {
fun handle(event: T)
}
采纳答案by Andrey Breslav
Assuming below that you really need EventHandleras a separate interface (e.g. for Java interop). If you don't, you can simply use a type alias (since Kotlin 1.1):
下面假设您确实需要EventHandler一个单独的接口（例如，用于 Java 互操作）。如果不这样做，您可以简单地使用类型别名（自 Kotlin 1.1 起）：
typealias EventHandler<T> = (T) -> Unit
In this case a simple lambda will work right away.
在这种情况下，一个简单的 lambda 将立即起作用。
But if you don't want to use a type alias, the issue still stands. It is that Kotlin only does SAM-conversion for functions defined in Java. Since Events.handleris defined in Kotlin, SAM-conversions do not apply to it.
但是如果您不想使用类型别名，问题仍然存在。Kotlin 只对 Java 中定义的函数进行 SAM 转换。由于Events.handler是在 Kotlin 中定义的，因此 SAM 转换不适用于它。
To support this syntax:
要支持此语法：
Events.handler(Handshake::class, EventHandler<Handshake> { println(it.sent) })
You can define a function named EventHandler:
您可以定义一个名为 的函数EventHandler：
fun <T> EventHandler(handler: (T) -> Unit): EventHandler<T>
= object : EventHandler<T> {
override fun handle(event: T) = handler(event)
}
To support this syntax:
要支持此语法：
Events.handler(Handshake::class, { println(it.sent) })
or this:
或这个：
Events.handler(Handshake::class) { println(it.sent) }
You need to overload the handlerfunction to take a function instead of EventHandler:
您需要重载handler函数以获取函数而不是EventHandler：
fun <T> Events.handler(eventType: Class<T>, handler: (T) -> Unit) = EventHandler(handler)
