Question

对于数据流场景，我需要以递归方式相互引用的值。以下不起作用：

class Foo(val that: Foo)

class Bar {
  lazy val a: Foo = new Foo(b)
  lazy val b: Foo = new Foo(a)
  println(s"a = $a, b = $b")
}

new Bar  // boom!

如果不用var来弄脏我怎么解决这个问题？

Answer 1

你只需要更多的懒惰！

class Foo(_that: => Foo){ lazy val that = _that }


class Bar {
  lazy val a: Foo = new Foo(b)
  lazy val b: Foo = new Foo(a)
  println(s"a = $a, b = $b")
}

val bar = new Bar

bar.b.that eq bar.a
// true

bar.b eq bar.a.that
// true

Answer 2

您可以使用by name参数和另一个lazy val：

class Foo(_that: => Foo) {
  lazy val that = _that
}

class Bar {
  lazy val a: Foo = new Foo(b)
  lazy val b: Foo = new Foo(a)
  println(s"a = $a, b = $b")
}

val bar = new Bar()
println(bar.a.that)

by name参数推断对其他Foo的引用的评估。访问that后，两个Foo都已创建，所以您没问题。

定义递归引用 - lazy val导致堆栈溢出

2 个答案: