Question

有一个密封的课程：

sealed class Alphabet(val name: String) {
  object A : Alphabet("A")
  object B : Alphabet("B")
  object C : Alphabet("C")
  object D : Alphabet("D")
  object E : Alphabet("E")

  companion object {
    val array = arrayOf(A, B, C, D, E)
    val list = listOf(A, B, C, D, E)
  }

  override fun toString(): String {
    return name
  }
}

还有另一个带有伴侣对象的类：

class AlphabetMap {

  companion object {
    val map = mapOf(
      Alphabet.A to 1,
      Alphabet.B to 2,
      Alphabet.C to 3,
      Alphabet.D to 4,
      Alphabet.E to 5
    )
  }
}

如果我想打印数组（或列表）：

class AlphabetTest {

  @Test
  fun printValues() {
    Alphabet.array.forEach { print("$it ") };println()
    Alphabet.list.forEach { print("$it ") };println()
  }
}

正确打印结果：

A B C D E 
A B C D E

但如果我在代码中初始化AlphabetMap：

class AlphabetTest {

  val m = AlphabetMap()

  @Test
  fun printValues() {
    Alphabet.array.forEach { print("$it ") };println()
    Alphabet.list.forEach { print("$it ") };println()
  }
}

结果神秘地变成：

null B C D E 
null B C D E

第一个元素（A）变为空

如果我定义

val m = AlphabetMap

结果是一样的。

如果我在函数中初始化AlphabetMap：

  @Test
  fun printValues() {
    val m = AlphabetMap()  // or val m = AlphabetMap
    Alphabet.array.forEach { print("$it ") };println()
    Alphabet.list.forEach { print("$it ") };println()
  }

结果是一样的：

null B C D E 
null B C D E

但如果我这样做：

  @Test
  fun printValues() {
    Alphabet.array.forEach { print("$it ") };println()
    val m = AlphabetMap() // or val m = AlphabetMap
    Alphabet.list.forEach { print("$it ") };println()
  }

现在一切正常：

A B C D E 
A B C D E

如果我将AlphabetMap重写为

class AlphabetMap {
  companion object {
    val map = mapOf(
      //Alphabet.A to 1,
      Alphabet.B to 2,
      Alphabet.C to 3,
      Alphabet.D to 4,
      Alphabet.E to 5
    )
  }
}

结果变为

A null C D E 
A null C D E

如果AlphebetMap是：

class AlphabetMap {
  companion object {
    val map = mapOf(
      Alphabet.E to 5
    )
  }
}

结果变为：

A B C D null 
A B C D null

可能出现什么问题？这是一个错误吗？或语言功能？

环境： jdk1.8.0_144，OS X

<kotlin.version>1.2.0</kotlin.version>
<kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>
<kotlin.compiler.incremental>false</kotlin.compiler.incremental>
<dependency>
  <groupId>org.jetbrains.kotlin</groupId>
  <artifactId>kotlin-stdlib</artifactId>
  <version>${kotlin.version}</version>
</dependency>

<dependency>
  <groupId>org.jetbrains.kotlin</groupId>
  <artifactId>kotlin-stdlib-jdk8</artifactId>
</dependency>
<dependency>
  <groupId>org.jetbrains.kotlin</groupId>
  <artifactId>kotlin-reflect</artifactId>
</dependency>
<dependency>
  <groupId>org.jetbrains.kotlinx</groupId>
  <artifactId>kotlinx-coroutines-core</artifactId>
</dependency>
<dependency>
  <groupId>org.jetbrains.kotlin</groupId>
  <artifactId>kotlin-test-junit</artifactId>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.jetbrains.kotlin</groupId>
  <artifactId>kotlin-test</artifactId>
  <scope>test</scope>
</dependency>

Answer 1

解决此问题的唯一方法是将地图定义移到类外：

val map = mapOf(
  Alphabet.A to 1,
  Alphabet.B to 2,
  Alphabet.C to 3,
  Alphabet.D to 4,
  Alphabet.E to 5
)

class AlphabetMap {
  companion object {

  }
}

根据JetBrain的reply on youtrack和reddit，这是 As Designed ，无法解决问题。

初始化周期问题没有一般解决方案。没有我们提出了哪些确切的规则，如果是初始化者对象A访问对象B和对象B的初始化程序访问对象A，其中一个将能够观察到另一个未初始化的国家。

Answer 2

另一种解决方案是定义array / list by lazy，这似乎可以解决这里的所有问题。

sealed class Alphabet(val name: String) {
  object A : Alphabet("A")
  object B : Alphabet("B")
  object C : Alphabet("C")
  object D : Alphabet("D")
  object E : Alphabet("E")

  companion object {
    val array: Array<Alphabet> by lazy {
      arrayOf(A, B, C, D, E)
    }
    val list: List<Alphabet> by lazy {
      listOf(A , B , C , D , E)
    }
  }

  override fun toString(): String {
    return name
  }
}

现在效果很好。

A B C D E 
A B C D E

密封类的对象在被其他伴随对象

2 个答案: