Kotlin允许相同的函数签名与属性getter具有不同的返回类型

Question

更新2020-12-23

open class BaseRequest {
    val params = mutableMapOf<String, String>()
    fun getParams(): List<String> {
        return params.values.toList()
    }
}

正如@slaw所说，这是kotlin编译器的行为，它是有效的，因为JVM使用地址而不是“签名”调用正确的方法。

我遇到了一种情况，似乎Kotlin允许子类创建与超类的getter相同的签名。

通常，函数具有相同的签名和不同的返回类型是不允许的。所以我对这种情况感到困惑。我不确定这是不是故意的。

open class BaseRequest {
    val params = mutableMapOf<String, String>()

    init {
        params["key1"] = "value1"
    }
}

class SpecificRequest : BaseRequest() {
    init {
        params["key2"] = "value2"
    }

    fun getParams(): List<String> {
        return params.values.toList()
    }
}

fun main() {
    val specificRequest = SpecificRequest()
    println("specificRequest.params: ${specificRequest.params}")
    println("specificRequest.getParams(): ${specificRequest.getParams()}")
    println("(specificRequest as BaseRequest).params: ${(specificRequest as BaseRequest).params}")
}

specificRequest.params: {key1=value1, key2=value2}
specificRequest.getParams(): [value1, value2]
(specificRequest as BaseRequest).params: {key1=value1, key2=value2}

如果我们看看反编译的Java代码，有两个方法具有相同的签名和不同的返回类型，这在Java中是不允许的。

java prettyprint-override">public class BaseRequest {
   @NotNull
   private final Map params;

   @NotNull
   public final Map getParams() {
      return this.params;
   }

   /* ... */
}


public final class SpecificRequest extends BaseRequest {
   @NotNull
   public final List getParams() {
      return CollectionsKt.toList((Iterable)this.getParams().values());
   }
   /* ... */
}

我知道函数名不合适，但有一个潜在的风险，即如果我们在.java中使用SpecificRequest,在将实例强制转换为它的超类之前，我们无法访问映射参数。而这可能会导致误解。

Answer 1

Java语言和JVM之间有区别。Java语言不允许在同一个类中声明两个名称相同但返回类型不同的方法。这是语言的限制。然而，JVM完全能够区分这两种方法。由于Kotlin是它自己的语言，它不一定要遵循与Java完全相同的规则--即使是在针对JVM时（因此编译为字节码）。

考虑以下Kotlin类：

class Foo {
    val bar = mapOf<Any, Any>()
    fun getBar() = listOf<Any>()
}

如果编译该类，然后使用javap检查字节码，您将看到：

Compiled from "Foo.kt"
public final class Foo {
  public final java.util.Map<java.lang.Object, java.lang.Object> getBar();
  public final java.util.List<java.lang.Object> getBar();
  public Foo();
}

fun test() {
    val foo = Foo()
    val bar1 = foo.bar
    val bar2 = foo.getBar()
}

 public static final void test();
    descriptor: ()V
    flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
    Code:
      stack=2, locals=3, args_size=0
         0: new           #8                  // class Foo
         3: dup
         4: invokespecial #11                 // Method Foo."<init>":()V
         7: astore_0
         8: aload_0
         9: invokevirtual #15                 // Method Foo.getBar:()Ljava/util/Map;
        12: astore_1
        13: aload_0
        14: invokevirtual #18                 // Method Foo.getBar:()Ljava/util/List;
        17: astore_2
        18: return

但有一个警告。以下内容将无法编译：

class Foo {
    fun getBaz() = mapOf<Any, Any>()
    fun getBaz() = listOf<Any>()
}

为什么？我不肯定，但我相信这与语法有关。Kotlin编译器总是可以根据您是使用foo.bar还是foo.getbar()轻松地判断要调用哪个函数。但是调用这两个getbaz()函数的语法是相同的，这意味着编译器不能在所有情况下很容易地判断您要调用哪个函数（因此它不允许上述操作）。