从Java到访问内部类私有成员的类的Kotlin的惯用迁移

Question

我有一个Java类（外层），它使用内部构建器类（外层。Builder），作为构建的一部分访问私有变量，如下所示：

import java.io.PrintStream;

public class Outer {
  private int mValue;

  private Outer(Builder builder) {
    mValue = builder.mValue;
  }

  public void printValue(PrintStream stream) {
    stream.println(mValue);
  }

  public static class Builder {
    private int mValue;

    public Builder setValue(int value) {
      mValue = value;
      return this;
    }

    public Outer build() {
      return new Outer(this);
    }
  }
}

使用方法如下：

class Main {
  public static void main(String[] args) {
    var builder = new Outer.Builder();
    var outer = builder.setValue(42).build();
    outer.printValue(System.out);
  }
}

我试图利用Android Studio将Java代码迁移到Kotlin的能力，这给了我以下结果：

import java.io.PrintStream

class Outer private constructor(builder: Builder) {
  private val mValue: Int

  fun printValue(stream: PrintStream) {
    stream.println(mValue)
  }

  class Builder {
    private var mValue = 0

    fun setValue(value: Int): Builder {
      mValue = value
      return this
    }

    fun build(): Outer {
      return Outer(this)
    }
  }

  init {
    mValue = builder.mValue
  }
}

但是，编译失败，出现以下情况：

Outer.kt:24:22: error: cannot access 'mValue': it is private in 'Builder'
    mValue = builder.mValue
                     ^

因为（如静态编程语言留档所述）：

在Kotlin中，外部类看不到内部类的私有成员。

此代码在init块中运行，其中：

mValue = builder.mValue

我知道我可以对其进行重构，以避免尝试这种访问（更改外部构造函数，使其包含所有成员，为必要的字段等向外部.Builder添加访问器），但我想知道是否有一种惯用的Kotlin方法来实现这种构建器模式（如果可能的话，只需对初始Java类进行最小的修改）。

Answer 1

静态编程语言具有命名参数，因此整个Builder模式嵌入到语言中：

class Outer(private val mValue: Int = 0) {
    fun printValue(stream: PrintStream) = stream.println(mValue)
}

//Usage:
fun main() {
    val outer = Outer(mValue = 42)
    outer.printValue(System.out)
}

然而，这种方法仅适用于Kotlin的使用。为了从Java使用，构造函数应该是私有的，并且应该声明传统的嵌套生成器：

class Outer private constructor(val mValue: Int) {
    class Builder {
        @set:JvmSynthetic // Hide 'void' setter from Java
        var mValue: Int = 0

        fun setValue(value: Int) = apply { this.mValue = value }

        fun build() = Outer(mValue)
    }

    fun printValue(stream: PrintStream) = stream.println(mValue)
}

为了方便地从Kotlin创建外部函数，我们需要声明一个辅助顶级函数，其名称与可用于复制构造函数的类型相同：

@JvmSynthetic // Hide from Java callers who should use Builder.
fun Outer(initializer: Outer.Builder.() -> Unit): Outer {
    return Outer.Builder().apply(initializer).build()
}

Java用法：

public class BuilderUsage {
    public static void main(String[] args) {
        Outer outer = new Outer.Builder().setValue(42).build();
        outer.printValue(System.out);
    }
}

静态编程语言的用法：

fun main() {
    val outer = Outer { mValue = 42 }
    outer.printValue(System.out)
}