我可以省略我在Kotlin中不使用的接口方法吗？

Question

如果我只对onSee其他事件感兴趣并且不关心其他事件怎么办？我能否至少省略没有返回值的方法？

interface EventHandler
{
    fun onSee()
    fun onHear()
    fun onSmell()
    fun onTouch()
    fun onAwake()
    fun onSleep()
}

fun addEventHandler(handler:EventHandler)
{

}

fun Main()
{
    addEventHandler(object:EventHandler
    {
        override fun onSee()
        {
            print("I see.")
        }
    })
}

Answer 1

当然,您只能实现一个接口方法,您所要做的就是为接口声明中的其他方法提供默认实现

interface EventHandler {
    fun onSee()
    fun onHear() { /* default implementation */ }
    fun onSmell(){ /* default implementation */ }
    fun onTouch(){ /* default implementation */ }
    fun onAwake(){ /* default implementation */ }
    fun onSleep(){ /* default implementation */ }
}

现在,当您创建此接口的实例时,您只需要为onSee()方法提供强制实现,其余是可选的

如果您不是原始界面的作者 您可以扩展原始界面并为所需方法提供默认实现

interface OnSeeEventHandler: EventHandler {
    override fun onHear() { /* default implementation */ }
    override fun onSmell(){ /* default implementation */ }
    override fun onTouch(){ /* default implementation */ }
    override fun onAwake(){ /* default implementation */ }
    override fun onSleep(){ /* default implementation */ }
}

并使用OnSeeEventHandler仅提供onSee方法imeplementation

Answer 2

我想出了以下，有点 p?e?r?v?e?r?s?e? 有趣的方法。

下面的函数使用动态代理来“实现”接口并仅使用所需的方法对其进行修补。未修补的方法将仅返回null或Unit，具体取决于返回类型。

import java.lang.reflect.Proxy.newProxyInstance

inline fun <reified T> Any.materialize(): T = materialize(T::class.java, this)

fun <T> materialize(i: Class<T>, x: Any = object {}): T {
    @Suppress("UNCHECKED_CAST")
    return newProxyInstance(i.classLoader, arrayOf(i)) { _, m, args ->
        x.javaClass.methods
                .asSequence()
                .filter {
                    it.name == m.name
                            && it.parameterTypes!!.contentEquals(m.parameterTypes)
                }
                .map {
                    it.invoke(x, *args.orEmpty())
                }.firstOrNull()
    } as T
}

给定一个接口Foo和一个仅包含其qux()功能实现的匿名对象，然后可以按如下方式使用它：

interface Foo {
    fun bar()
    fun baz(): String
    fun qux(s: String): String
}

fun main(vararg args: String) {
    val foo = object {
        fun qux(s: String): String {
            return "Returned from qux: $s"
        }
    }.materialize<Foo>()

    println(foo.bar()) // void no-op, prints "kotlin.Unit"
    println(foo.baz()) // no-op with return value, prints "null"
    println(foo.qux("Hello")) // prints "Returned from qux: Hello"

}

免责声明

• 使用它，您将失去所有编译时检查，因为一切都在运行时解决。
• 此实现未涵盖某些内容（例如接口默认方法）。
• 根本不考虑性能。
• 需要kotlin-reflect依赖。
• 今天是我学习 Kotlin 的第二天，所以可能会有许多未解决的边缘情况和错误。

在大多数情况下，我自己不会使用它，并且会继续支持支持部分接口实现的 Kotlin 构造（如 TypeScript 的Partial<T>）。

我只是提供这种方法，因为它可能对某些用例感兴趣，如果这让你的眼睛流血，我很抱歉。