Scala 实例化不可变的成对对象

是否可以创建一个对伙伴对象具有不可变引用的类，或者它必须是创建后分配的

var

e、 g

或者类似地，我如何实例化下面的一对

class Chicken (e: Egg) { 
  val offspring = e
}

class Egg (c: Chicken) {
  val mother = c
}

---

如果您的问题是循环引用，您可以使用此问题中发布的解决方案：

---

这就解决了鸡/蛋问题。

以下是鸡/蛋问题的完整解决方案：

class Chicken (e: =>Egg) { 
  lazy val offspring = e 
}

class Egg (c: =>Chicken) {
  lazy val mother = c
}

lazy val chicken: Chicken = new Chicken(egg)
lazy val egg: Egg         = new Egg(chicken)

请注意，您必须为

chicken

和

egg

变量提供显式类型

对于PaireObject：

class PairedObject (p: => PairedObject, val id: String) {
  lazy val partner: PairedObject = p
}

lazy val p1: PairedObject = new PairedObject(p2, "P1")
lazy val p2: PairedObject = new PairedObject(p1, "P2")

---

如果我只有两个

case对象

s，效果很好：只需将val

设置为lazy

。我还为PairedObject添加了解决方案。我还发现

鸡

和

蛋

的VAL不需要懒惰。严格来说，您不需要为这两种类型都包含类型，因为可以推断出一种类型。如果在

类

或

对象

定义的顶层输入，此解决方案将起作用，但如果

鸡

和

蛋

是局部变量（例如，在函数内部），则会出现非法的正向引用错误。一个在任何范围内都有效的解决方案是：

lazy val（egg:egg，chicken:chicken）=……

，它可以是自我参照的。@KiptonBarros--我认为你应该写下你的评论作为回答，因为，对不起，Eric，尽管回答很巧妙，但如果没有KB的改进，它是非常不完整的。更多信息，请参阅。@Malvolio这是我的错：我在2.9版的

App

对象中测试了这个问题，这解释了为什么不需要

lazy

。正如@Kipton所指出的，更一般地说，它将在它所在的函数中。我已经将它编辑回Eric的原始版本。这是一个很好的解决方案，但请注意，lazy val有点“欺骗”，因为编译器生成的变量可以在内部进行一次变异（第一次访问时）。

class PairedObject (p: => PairedObject, val id: String) {
  lazy val partner: PairedObject = p
}

lazy val p1: PairedObject = new PairedObject(p2, "P1")
lazy val p2: PairedObject = new PairedObject(p1, "P2")