Case Classes
Unveränderliche Datenträger
Case Classes ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Was ist eine Case Class?
Eine Case Class ist eine besondere Klassenart, die zum Speichern unveränderlicher Daten entwickelt wurde. Sie wird mit case class deklariert.
Scala generiert automatisch viel nützlichen Code. Dadurch sind Case Classes die bevorzugte Möglichkeit, Daten zu modellieren.
Eine deklarieren
Geben Sie einfach die Felder in der Parameterliste an. Jeder Parameter wird zu einem unveränderlichen Feld.
Zum Erstellen einer Instanz ist kein Schlüsselwort new erforderlich.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(3, 4)
println(p.x)
println(p.y)
}
}Automatisches toString
Case Classes erhalten kostenlos eine lesbare toString-Methode, die den Klassennamen und die Feldwerte anzeigt.
Das macht Debugging und Logging mühelos.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Wertgleichheit
Case Classes werden anhand ihres Werts und nicht anhand ihrer Referenz verglichen. Zwei Instanzen mit denselben Feldern sind gleich.
Normale Klassen würden stattdessen anhand ihrer Identität verglichen.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val a = Point(1, 2)
val b = Point(1, 2)
println(a == b)
}
}Unveränderliche Felder
Felder von Case Classes sind standardmäßig val und können daher nicht neu zugewiesen werden.
Für eine veränderte Version erstellen Sie eine neue Instanz, statt die alte zu verändern.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}Die copy-Methode
Jede Case Class besitzt eine copy-Methode. Sie erstellt eine neue Instanz, wobei Sie nur die angegebenen Felder ändern können.
Dies ist die idiomatische Methode, unveränderliche Daten zu aktualisieren.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
val moved = p.copy(y = 99)
println(p)
println(moved)
}
}Unterstützung für Pattern Matching
Case Classes funktionieren nahtlos mit match. Sie können sie dekonstruieren, indem Sie ihre Felder in einem Muster benennen.
Dies ist einer der wichtigsten Gründe, sie zu verwenden.
case class Point(x: Int, y: Int)
object Main {
def describe(p: Point): String = p match {
case Point(0, 0) => "origin"
case Point(x, 0) => s"on x-axis at $x"
case Point(x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(describe(Point(0, 0)))
println(describe(Point(5, 0)))
println(describe(Point(2, 3)))
}
}Standardwerte für Parameter
Wie normale Klassen können Case Classes Standardwerte für Parameter besitzen, sodass Sie diese beim Erstellen weglassen können.
case class User(name: String, active: Boolean = true)
object Main {
def main(args: Array[String]): Unit = {
val u1 = User("Ada")
val u2 = User("Bo", false)
println(u1)
println(u2)
}
}Methoden hinzufügen
Eine Case Class kann wie jede Klasse eigene Methoden im Rumpf enthalten. Diese arbeiten mit den unveränderlichen Feldern.
case class Rect(w: Int, h: Int) {
def area: Int = w * h
}
object Main {
def main(args: Array[String]): Unit = {
val r = Rect(3, 4)
println(r.area)
}
}Warum Case Classes?
Case Classes bieten Ihnen kostenlos:
- einen kompakten Konstruktor mit unveränderlichen Feldern
- eine lesbare
toString-Methode - wertbasierte Implementierungen von
equalsundhashCode - eine
copy-Methode - erstklassige Unterstützung für Pattern Matching
Sie bilden die Grundlage für die Modellierung von Daten in Scala.
Alles zusammenführen
In diesem Beispiel wird eine Case Class erstellt, kopiert, verglichen und per Pattern Matching abgeglichen.
case class Money(amount: Int, currency: String)
object Main {
def main(args: Array[String]): Unit = {
val price = Money(10, "USD")
val sale = price.copy(amount = 8)
println(price == sale)
sale match {
case Money(a, "USD") => println(s"$a dollars")
case Money(a, c) => println(s"$a $c")
}
}
}Kurze Überprüfung
Testen Sie Ihr Verständnis von Case Classes.
Zusammenfassung
Sie haben gelernt, dass eine case class unveränderliche Daten mit generierten Hilfsmethoden modelliert:
- Instanziieren ohne
new; Felder sind unveränderlichevals - Kostenloses
toStringsowie wertbasierte Implementierungen vonequals/hashCode copyerstellt veränderte Kopien- Integrierte Unterstützung für Pattern Matching
- Standardwerte und eigene Methoden sind möglich
Häufig gestellte Fragen
Ist die Lektion „Case Classes“ kostenlos?
Ja — der vollständige Text von „Case Classes“ 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 „Case Classes“?
Unveränderliche Datenträger 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 1 von 4.
Wie lange dauert die Lektion „Case Classes“?
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.