为什么在 Scala 中被覆盖的变量会得到错误的值？

Question

我在 Scala 中有一个 A 类，比如这个：

class A {
  val a = 3
  lazy val b = 2
  println("a = " + a)
  println("b = " + b)
}

接下来，我将这个类扩展到另一个类B：

class B extends A {
  override val a = 4
  override lazy val b = 3
}

现在，当我创建class B 的对象时，我得到以下输出：

a = 0  //the default value of int is zero `0` in Scala
b = 3

而我期望输出是：

a = 3
b = 2

我的问题是class A 中的println() 函数如何知道class B 中定义的值，但只知道b 而不是a？

Answer 1

docs.scala-lang.org - tutorials - initialization-order 提供了完整的解释。

---

为了看得更清楚，让我们在B 类中打印与A 类中相同的内容：

class A {
  val a = 3
  lazy val b = 2
  println("A: a = " + a)
  println("A: b = " + b)
}

class B extends A {
  override val a = 4
  override lazy val b = 3
  println("B: a = " + a)
  println("B: b = " + b)
}

在这种情况下，new B() 产生：

A: a = 0
A: b = 3
B: a = 4
B: b = 3

---

非惰性val变量的初始化顺序为：

在没有“早期定义”（见下文）的情况下，初始化 严格的 vals 按以下顺序完成。

1. 超类在子类之前完全初始化。
2. 否则，按申报顺序。

因此A 在B 之前完全初始化。

但是val 不能被多次初始化。因此，在首先处理超类 A 时，Scala 在内部给它一个默认值（0 为 Int，null 为 String，..）。

因此它首先打印0（初始化A）然后打印4（初始化B）。

---

使用lazy vals 是scaladoc 提出的绕过这个限制的解决方案。

Answer 2

为什么lazy val 按预期工作？因为val 被lazy 标记将在其第一次访问时被初始化。

为什么 non-lazy 不能按预期工作？因为初始化顺序。

非惰性值被初始化in the following order:

1. 超类在子类之前完全初始化。
2. 否则，按申报顺序。

在您的示例中，您尝试访问 override val，但在构造超类期间，override val 将显示为 null。

包含更多日志的代码以查看初始化顺序：

class A {
  println("First line of A")
  val strictVal: String = {
    println("A.strictVal called")
    "strictVal of A"
  }
  lazy val lazyVal: String = {
    println("A.lazyVal called")
    "lazyVal of A"
  }

  println(s"lazyVal = $lazyVal")
  println(s"strictVal = $strictVal")

  println("Last line of A")
}

class B extends A {
  println("First line of B")
  override val strictVal: String = {
    println("B.strictVal called")
    "strictVal of B"
  }

  override lazy val lazyVal: String = {
    println("B.lazyVal called")
    "lazyVal of B"
  }
  println("Last line of B")
}

new B() 的输出：

First line of A
A.strictVal called
B.lazyVal called
lazyVal = lazyVal of B
strictVal = null
Last line of A
First line of B
B.strictVal called
Last line of B