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< Handshake> {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) }

这是我的活动对象：

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 interface：

And my EventHandler interface:

@FunctionalInterface
interface EventHandler<T> {

    fun handle(event: T)

}

推荐答案

假设下面你真的需要 EventHandler 作为一个单独的接口（例如对于Java互操作）。如果不这样做，您可以简单地使用类型别名（因为Kotlin 1.1）：

Assuming below that you really need EventHandler as a separate interface (e.g. for Java interop). If you don't, you can simply use a type alias (since Kotlin 1.1):

typealias EventHandler<T> = (T) -> Unit

在这种情况下，简单的lambda将立即生效。

In this case a simple lambda will work right away.

但是如果你不想使用类型别名，问题仍然存在。 Kotlin只对Java中定义的函数进行SAM转换。由于 Events.handler 是在Kotlin中定义的，因此SAM转换不适用于它。

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.handler is defined in Kotlin, SAM-conversions do not apply to it.

支持此语法：

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

您可以定义一个名为 EventHandler 的函数：

You can define a function named EventHandler:

fun <T> EventHandler(handler: (T) -> Unit): EventHandler<T> 
    = object : EventHandler<T> { 
        override fun handle(event: T) = handler(event) 
    }

支持这种语法：

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

或者这个：

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

你需要重载处理程序函数来取代函数而不是 EventHandler ：

You need to overload the handler function to take a function instead of EventHandler:

fun <T> Events.handler(eventType: Class<T>, handler: (T) -> Unit) = EventHandler(handler)

注意：当未来版本的Kotlin具有类型别名时，将不需要 EventHandler 接口，因为它将被命名的别名替换为输入（T） - >单位

NOTE: When a future version of Kotlin has type aliases, the EventHandler interface won't be needed, because it will be replaced by a named alias to the type (T) -> Unit

这篇关于Kotlin：使用lambda代替功能界面？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！