Enums in Scala 3
Neue Enum-Syntax
Enums in Scala 3 ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Das neue Schlüsselwort enum
Scala 3 ergänzt ein erstklassiges Konstrukt namens enum. Es ersetzt das ausführliche Muster aus Sealed Trait und Case Objects aus Scala 2 durch eine kompakte Syntax.
- Jeder Case wird zu einem Wert des Enum-Typs.
- Der Compiler generiert automatisch nützliche Hilfsmethoden.
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
println(Color.Red)Alle Werte auflisten
Jedes einfache Enum erhält ein Companion mit values (einem Array aller Cases) und valueOf (Suche nach Namen).
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
Color.values.foreach(println)
println(Color.valueOf("Green"))Ordinalwert und Name
Jeder Enum-Wert besitzt ein ordinal (eine nullbasierte Position) und ein generiertes toString, das seinen Case-Namen verwendet.
enum Color:
case Red, Green, Blue
object Main:
def main(args: Array[String]): Unit =
println(Color.Blue.ordinal)
println(Color.Red.ordinal)Enums mit Parametern
Enum-Cases können Konstruktorparameter annehmen und jedem Wert zugehörige Daten geben. Das eignet sich beispielsweise zum Speichern von Konstanten wie RGB-Codes oder Planetenmassen.
enum Planet(val mass: Double):
case Earth extends Planet(5.97e24)
case Mars extends Planet(6.42e23)
object Main:
def main(args: Array[String]): Unit =
println(Planet.Earth.mass)
println(Planet.Mars.mass)Methoden in Enums
Sie können Methoden im Körper eines Enums definieren. Sie sind für jeden Wert verfügbar, genau wie Methoden einer Klasse.
enum Direction:
case North, South, East, West
def opposite: Direction = this match
case North => South
case South => North
case East => West
case West => East
object Main:
def main(args: Array[String]): Unit =
println(Direction.North.opposite)Generische ADT-Enums
Enums können generisch und parametrisiert sein, sodass Sie algebraische Datentypen modellieren können. Hier sehen Sie einen vereinfachten Option-Typ.
enum Maybe[+A]:
case Just(value: A)
case Nothing
object Main:
def main(args: Array[String]): Unit =
val a: Maybe[Int] = Maybe.Just(42)
println(a)Rekursive ADT-Enums
Bei rekursiven Strukturen spielen Enums ihre Stärken aus. Ein Binärbaum oder eine verkettete Liste lässt sich übersichtlich als eine Menge von Cases darstellen.
enum Tree[+A]:
case Leaf(value: A)
case Branch(left: Tree[A], right: Tree[A])
object Main:
def main(args: Array[String]): Unit =
val t = Tree.Branch(Tree.Leaf(1), Tree.Leaf(2))
println(t)Pattern Matching auf Enums
Da Enums sealed sind, kann der Compiler die Vollständigkeit prüfen eines Match-Ausdrucks. Fehlt ein Case, wird eine Warnung ausgegeben.
enum Light:
case Red, Yellow, Green
object Main:
def action(l: Light): String = l match
case Light.Red => "stop"
case Light.Yellow => "slow"
case Light.Green => "go"
def main(args: Array[String]): Unit =
println(action(Light.Green))Java-kompatible Enums
Fügen Sie das Verhalten von java.lang.Enum hinzu, indem Sie automatisch von scala.reflect.Enum ableiten. Für echte Java-Interoperabilität schreiben Sie enum X extends Enum[X] ... Meist genügt jedoch die einfache Form, die bei Bedarf gut mit Java interagiert.
enum Suit:
case Hearts, Diamonds, Clubs, Spades
object Main:
def main(args: Array[String]): Unit =
println(Suit.values.length)
println(Suit.Spades.ordinal)Felder und Methoden kombinieren
Sie können parametrisierte Cases mit gemeinsamen Methoden kombinieren, um umfangreiche Domänenmodelle zu erstellen.
enum Currency(val symbol: String):
case USD extends Currency("$")
case EUR extends Currency("\u20ac")
def format(amount: Double): String = s"$symbol$amount"
object Main:
def main(args: Array[String]): Unit =
println(Currency.USD.format(9.99))Wann Sie enum verwenden sollten
Verwenden Sie enum, wenn Sie eine abgeschlossene Menge von Auswahlmöglichkeiten oder einen algebraischen Datentyp haben.
- Einfache Cases für gewöhnliche Aufzählungen.
- Parametrisierte Cases für ADTs und Sum Types.
- Die automatische Vollständigkeitsprüfung macht Refactorings sicher.
enum Result[+E, +A]:
case Ok(value: A)
case Err(error: E)
object Main:
def main(args: Array[String]): Unit =
val r: Result[String, Int] = Result.Ok(7)
println(r)Kurzer Check
Testen Sie Ihr Verständnis von Scala-3-Enums.
Zusammenfassung
Sie haben Scala-3-Enums kennengelernt.
- Das kompakte
enumersetzt das Boilerplate von Sealed Traits. - Einfache Enums erhalten
values,valueOfundordinal. - Cases können für zugehörige Daten Parameter annehmen.
- Generische und rekursive Enums modellieren ADTs.
- Die Sealed-Eigenschaft ermöglicht vollständiges Pattern Matching.
enum Weekday:
case Mon, Tue, Wed, Thu, Fri
def isStart: Boolean = this == Mon
object Main:
def main(args: Array[String]): Unit =
println(Weekday.Mon.isStart)
println(Weekday.values.length)Häufig gestellte Fragen
Ist die Lektion „Enums in Scala 3“ kostenlos?
Ja — der vollständige Text von „Enums in Scala 3“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Enums in Scala 3“?
Neue Enum-Syntax Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Enums in Scala 3“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.