默认参数和@JvmOverloads 如何在 Kotlin 上工作？

Question

当我们像这样用 Kotlin 创造乐趣时

fun foo(bar: Int = 0, baz: Int) { /* ... */ }

foo(baz = 1) // The default value bar = 0 is used

所以在java中我们需要这样写例如

不用写

void foo(int bar, int baz){
...
}

void foo(int baz){
foo(0,baz);
}

让我们想象一下，如果我们有 10 个以上的参数。我想知道 Kotlin 是如何处理这个问题的。 Kotlin 会生成所有可能的方法吗？或者它只是生成程序员真正使用的方法？

Answer 1

来自documentation：

Instructs the Kotlin compiler to generate overloads for this function that substitute default parameter values.

If a method has N parameters and M of which have default values, M overloads are generated: the first one takes N-1 parameters (all but the last one that takes a default value), the second takes N-2 parameters, and so on.

Answer 2

当你有一个带有默认参数的函数时，Kotlin 会生成一个合成函数，其中包含所需的参数和一个附加的 Int 作为最后一个参数，并进行一些位操作

示例 Kotlin 函数：

fun lotsOfParameters(a: String = "Default",
                     b: Byte = 2,
                     c: Char = 'p',
                     d: Boolean = false,
                     e: Any = true,
                     f: Int = 2) {
}

编译Java代码：

public static final void lotsOfParameters(@NotNull String a, byte b, char c, boolean d, @NotNull Object e, int f) {
  Intrinsics.checkParameterIsNotNull(a, "a");
  Intrinsics.checkParameterIsNotNull(e, "e");
}

// $FF: synthetic method
// $FF: bridge method
public static void lotsOfParameters$default(String var0, byte var1, char var2, boolean var3, Object var4, int var5, int var6, Object var7) {
  if ((var6 & 1) != 0) {
     var0 = "Default";
  }

  if ((var6 & 2) != 0) {
     var1 = 2;
  }

  if ((var6 & 4) != 0) {
     var2 = 'p';
  }

  if ((var6 & 8) != 0) {
     var3 = false;
  }

  if ((var6 & 16) != 0) {
     var4 = true;
  }

  if ((var6 & 32) != 0) {
     var5 = 2;
  }

  lotsOfParameters(var0, var1, var2, var3, var4, var5);
}

Answer 3

不会生成 2^N 次重载。正如docs、

中所说

For every parameter with a default value, this will generate one additional overload, which has this parameter and all parameters to the right of it in the parameter list removed.

对于具有默认参数的函数，例如，

 fun foo(bar: Int = 1, baz: Int = 2, qux: Int = 3) { /*...*/ }

它会产生过载

 foo()
 foo(bar)
 foo(bar, baz)
 foo(bar, baz, qux)

默认参数和@JvmOverloads 如何在 Kotlin 上工作？

How Default argument and @JvmOverloads work on Kotlin?

java

default-arguments

kotlin