Question

有没有办法将函数的返回类型指定为被调用对象的类型？

e.g。

trait Foo {
    fun bar(): <??> /* what to put here? */ {
        return this
    }
}

class FooClassA : Foo {
    fun a() {}
}

class FooClassB : Foo {
    fun b() {}
}

// this is the desired effect:
val a = FooClassA().bar() // should be of type FooClassA
a.a()                     // so this would work

val b = FooClassB().bar() // should be of type FooClassB
b.b()                     // so this would work

实际上，这大致相当于Objective-C中的instancetype或Swift中的Self。

Answer 1

没有支持此功能的语言功能，但您始终可以使用递归泛型（这是许多库使用的模式）：

// Define a recursive generic parameter Me
trait Foo<Me: Foo<Me>> {
    fun bar(): Me {
        // Here we have to cast, because the compiler does not know that Me is the same as this class
        return this as Me
    }
}

// In subclasses, pass itself to the superclass as an argument:
class FooClassA : Foo<FooClassA> {
    fun a() {}
}

class FooClassB : Foo<FooClassB> {
    fun b() {}
}

Answer 2

您可以使用extension functions返回自己的类型。

interface ExampleInterface
// Everything that implements ExampleInterface will have this method.
fun <T : ExampleInterface> T.doSomething(): T {
    return this
}

class ClassA : ExampleInterface {
    fun classASpecificMethod() {}
}

class ClassB : ExampleInterface {
    fun classBSpecificMethod() {}
}

fun example() {
    // doSomething() returns ClassA!
    ClassA().doSomething().classASpecificMethod()
    // doSomething() returns ClassB!
    ClassB().doSomething().classBSpecificMethod()
}

Answer 3

您可以使用extension method来实现＆＃34;返回相同的类型＆＃34;影响。这是一个快速示例，显示了具有多个类型参数的基类型，以及一个扩展方法，该方法接受一个对所述类型的实例进行操作的函数：

public abstract class BuilderBase<A, B> {}

public fun <B : BuilderBase<*, *>> B.doIt(): B {
  // Do something
  return this
}

public class MyBuilder : BuilderBase<Int,String>() {}

public fun demo() {
  val b : MyBuilder = MyBuilder().doIt()
}

由于扩展方法是静态解析的（至少从M12开始），如果需要特定于类型的行为，您可能需要让扩展委托实际的实现到this。

Answer 4

递归类型绑定

您在问题中展示的模式在 JVM 世界中被称为递归类型绑定。递归类型包括一个函数，该函数使用该类型本身作为其参数或返回值的类型。在您的示例中，您通过说 return this 为返回值使用相同的类型。

示例

让我们通过一个简单而真实的例子来理解这一点。我们会将您示例中的 trait 替换为 interface，因为 trait 现在在 Kotlin 中已被弃用。在此示例中，接口 VitaminSource 返回不同维生素来源的不同实现。

在下面的 interface 中，可以看到它的类型参数以自身为上限。这就是为什么它被称为递归类型绑定：

VitaminSource.kt

interface VitaminSource<T: VitaminSource<T>> {
    fun getSource(): T {
        @Suppress("UNCHECKED_CAST")
        return this as T
    }
}

我们取消了 UNCHECKED_CAST 警告，因为编译器不可能知道我们是否传递了相同的类名作为类型参数。

然后我们用具体的实现来扩展 interface：

Carrot.kt

class Carrot : VitaminSource<Carrot> {
    fun getVitaminA() = println("Vitamin A")
}

香蕉.kt

class Banana : VitaminSource<Banana> {
    fun getVitaminB() = println("Vitamin B")
}

在扩展类时，您必须确保将相同的类传递给接口，否则您将在运行时得到 ClassCastException：

class Banana : VitaminSource<Banana>    // OK
class Banana : VitaminSource<Carrot>    // No compiler error but exception at runtime

Test.kt

fun main() {
    val carrot = Carrot().getSource()
    carrot.getVitaminA()

    val banana = Banana().getSource()
    banana.getVitaminB()
}

就是这样！希望有所帮助。

Answer 5

您也可以通过扩展功能来实现。

class Foo
fun <T: Foo>T.someFun(): T {
    return this
}
Foo().someFun().someFun()

Answer 6

根据具体的用例，scope functions 可能是一个不错的选择。对于构建器模式，apply 似乎最有用，因为上下文对象是 this，作用域函数的结果也是 this。

考虑这个带有专门构建器子类的 List 构建器的例子：

open class ListBuilder<E> {
    // Return type does not matter, could also use Unit and not return anything
    // But might be good to avoid that to not force users to use scope functions
    fun add(element: E): ListBuilder<E> {
        ...
        
        return this
    }

    fun buildList(): List<E> {
        ...
    }
}

class EnhancedListBuilder<E>: ListBuilder<E>() {
    fun addTwice(element: E): EnhancedListBuilder<E> {
        addNTimes(element, 2)
        return this
    }

    fun addNTimes(element: E, times: Int): EnhancedListBuilder<E> {
        repeat(times) {
            add(element)
        }
        return this
    }
}

// Usage of builder:
val list = EnhancedListBuilder<String>().apply { 
    add("a") // Note: This would return only ListBuilder
    addTwice("b")
    addNTimes("c", 3)
}.buildList()

然而，这仅在所有方法都具有 this 作为结果时有效。如果其中一个方法实际上创建了一个新实例，那么该实例将被丢弃。

这是基于对类似问题的 this answer。

如何在Kotlin中指定“自己的类型”作为返回类型

6 个答案:

递归类型绑定

示例