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

我想出了以下一些有趣的方法。

下面的函数使用dynamic proxy来“物化”接口并仅使用所需的方法对其进行修补。未修补的方法将仅返回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的第二天，所以可能有许多未解决的边缘案例和错误。


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

我只提供   这种方法，因为它可能在某些用例中很有趣，我   抱歉，如果这使您的眼睛流血。

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

2 个答案: