Kotlin 科特林的StackOverflowerr

我是kotlin的新手，我对代码有一个问题：我不知道为什么在创建类的实例时会出现stackoverflow错误

代码如下：

class Spice(val spiceName: String,val spiciness: String = "mild") {

    init {
        println("[$spiceName - $spiciness] ")
    }

    val spiceList: List<Spice> = listOf(
            Spice("curry", "mild"),
            Spice("pepper", "medium"),
            Spice("cayenne", "spicy"),
            Spice("ginger", "mild"),
            Spice("red curry", "medium"),
            Spice("green curry", "mild"),
            Spice("hot pepper", "extremely spicy"))

    val heat: Int
        get() {
            return when (spiciness) {
                "mild" -> 1
                "medium" -> 3
                "spicy" -> 5
                "very spicy" -> 7
                "extremely spicy" -> 10
                else -> 0
            }
        }


    fun makeSalt() = Spice("Salt")

}

class Spice（val-spiceName:String，val-spiciness:String=“温和”）{
初始化{
println（“[$spiceName-$spiciness]”）
}
val spiceList:List=listOf(
香料（“咖喱”、“温和”），
香料（“胡椒”，“中等”），
香料（“辣椒”、“辣味”），
香料（“姜味”、“淡味”），
香料（“红咖喱”、“中等”），
香料（“绿咖喱”、“淡味”），
香料（“辣椒”、“极辣”））
瓦尔热：Int
得到（）{
返回时（辣度）{
“轻度”->1
“中等”->3
“辣”->5
“非常辣”->7
“极辣”->10
其他->0
}
}
调味品（盐）
}

这是因为

Spice列表

字段：每个

Spice

实例将尝试初始化此字段，从而创建一个

Spice

列表，每个实例将创建一个新列表，依此类推

---

您可以将

spiceList

移动到a，使其与类而不是其实例绑定。

这是因为

spiceList

字段：Spice的每个实例都将尝试初始化此字段，从而创建

Spice

的列表，每个实例都将创建一个新列表，依此类推

---

您可以将

Spice列表

移动到，使其绑定到类，而不是它的实例。

这是因为无论何时调用

Spice（）

类，您都要创建一个新的实例

val spiceList: List<Spice> = listOf(
  Spice("curry", "mild"),
  Spice("pepper", "medium"),
  Spice("cayenne", "spicy"),
  Spice("ginger", "mild"),
  Spice("red curry", "medium"),
  Spice("green curry", "mild"),
  Spice("hot pepper", "extremely spicy"))

然后，当您通过

init

时，您将继续进行评估

val spiceList = listOf(....)

在Kotlin中，赋值是在运行时解析的，这意味着，即使您没有使用

spiceList

，您仍然在该行创建它，以及其中的所有其他

Spice（）

对象

你会注意到在你得到stackoverflow之前，你实际上是在打印

[Whatever you passed in for your first param, "mild"]
["curry", "mild"] x thousands of times

因为您在Spices中实例化Spices，所以您将始终处于该循环中

---

您可以将列表移动到一个伴随对象，该对象将被视为Java中的静态对象，这样一来，无论何时实例化Spice类，它都不会被解析。这是因为无论何时调用

val spiceList: List<Spice> = listOf(
  Spice("curry", "mild"),
  Spice("pepper", "medium"),
  Spice("cayenne", "spicy"),
  Spice("ginger", "mild"),
  Spice("red curry", "medium"),
  Spice("green curry", "mild"),
  Spice("hot pepper", "extremely spicy"))

然后，当您通过

init

时，您将继续进行评估

val spiceList = listOf(....)

在Kotlin中，赋值是在运行时解析的，这意味着，即使您没有使用

spiceList

，您仍然在该行创建它，以及其中的所有其他

Spice（）

对象

你会注意到在你得到stackoverflow之前，你实际上是在打印

[Whatever you passed in for your first param, "mild"]
["curry", "mild"] x thousands of times

因为您在Spices中实例化Spices，所以您将始终处于该循环中

您可以将列表移动到一个伴随对象，该对象将被视为Java中的静态对象，这样一来，每当您实例化Spice类时，它就不会被解析

val spiceList: List<Spice> = listOf(
Spice("curry", "mild"),
Spice("pepper", "medium"),
Spice("cayenne", "spicy"),
Spice("ginger", "mild"),
Spice("red curry", "medium"),
Spice("green curry", "mild"),
Spice("hot pepper", "extremely spicy"))

val-spiceList:List=listOf(
香料（“咖喱”、“温和”），
香料（“胡椒”，“中等”），
香料（“辣椒”、“辣味”），
香料（“姜味”、“淡味”），
香料（“红咖喱”、“中等”），
香料（“绿咖喱”、“淡味”），
香料（“辣椒”、“极辣”））

您正在每个实例中创建香料列表，列表中的每个香料项目正在创建香料列表，依此类推，然后您将面临突发事件！。 在这种情况下，您可以使用密封类，或者只使用companion对象将其作为静态列表。

这里是您的错误：

val spiceList: List<Spice> = listOf(
Spice("curry", "mild"),
Spice("pepper", "medium"),
Spice("cayenne", "spicy"),
Spice("ginger", "mild"),
Spice("red curry", "medium"),
Spice("green curry", "mild"),
Spice("hot pepper", "extremely spicy"))

val-spiceList:List=listOf(
香料（“咖喱”、“温和”），
香料（“胡椒”，“中等”），
香料（“辣椒”、“辣味”），
香料（“姜味”、“淡味”），
香料（“红咖喱”、“中等”），
香料（“绿咖喱”、“淡味”），
香料（“辣椒”、“极辣”））

您正在每个实例中创建香料列表，列表中的每个香料项目正在创建香料列表，依此类推，然后您将面临突发事件！。 在这种情况下，您可以使用一个密封的类，或者只使用companion对象将其作为静态列表