Kotlin:使用 lambda 代替函数式接口? [英] Kotlin: Use a lambda in place of a functional interface?

问题描述

在Java中我们可以这样做Events.handler(Handshake.class, hs -> out.println(hs));

In Java we can do this Events.handler(Handshake.class, hs -> out.println(hs));

然而，在 Kotlin 中，我试图复制行为来替换它:

In Kotlin however I am trying to replicate the behavior to replace this:

Events.handler(Handshake::class, object : EventHandler<Handshake> {
    override fun handle(event: Handshake) {
        println(event.sent)
    }
})

用起来更方便:

Events.handler(Handshake::class, EventHandler { println(it.sent) })

出于某种原因参考EventHandler:

更可取的是，我想使用更短的东西:Events.handler(Handshake::class, { println(it.sent) })

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 对象:

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>>
    }

}

还有我的 EventHandler 接口:

@FunctionalInterface
interface EventHandler<T> {

    fun handle(event: T)

}

推荐答案

自从@andrey-breslav 发布答案以来，Kotlin 发生了很多好事.他提到:

A lot of nice things has happened to Kotlin since @andrey-breslav posted the answer. He mentions:

这是 Kotlin 只对定义的函数进行 SAM 转换爪哇.由于 Events.handler 是在 Kotlin 中定义的，因此 SAM 转换可以不适用于它.

It is that Kotlin only does SAM-conversion for functions defined in Java. Since Events.handler is defined in Kotlin, SAM-conversions do not apply to it.

好吧，Kotlin 不再是这种情况1.4+.如果您将接口标记为功能性"接口，它可以对 Kotlin 函数使用 SAM 转换:

Well, that's no longer the case for Kotlin 1.4+. It can use SAM-conversion for Kotlin functions if you mark an interface as a "functional" interface:

// notice the "fun" keyword
fun interface EventHandler<T> {
    fun handle(event: T)
}

您可以在此处阅读 YouTrack 票:https://youtrack.jetbrains.com/issue/KT-7770.还有一个解释，为什么 Kotlin 需要一个与 Java 不同的接口的标记(@FunctionalInterface 只是提供信息，对编译器没有影响).

You can read the YouTrack ticket here: https://youtrack.jetbrains.com/issue/KT-7770. There's also an explanation why Kotlin needs a marker for such interfaces unlike Java (@FunctionalInterface is only informational and has no effect on the compiler).

这篇关于Kotlin:使用 lambda 代替函数式接口?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！