Case classes
Onveranderlijke gegevensdragers
Case classes is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.
Wat is een caseklasse?
Een caseklasse is een speciaal soort klasse die is ontworpen om onveranderlijke gegevens te bevatten. Je declareert deze met case class.
Scala genereert automatisch veel nuttige code voor je, waardoor caseklassen de standaardkeuze zijn voor het modelleren van gegevens.
Een caseklasse declareren
Som de velden gewoon op in de parameterlijst. Elke parameter wordt een onveranderlijk veld.
Om een instantie te maken is het sleutelwoord new niet nodig.
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)
}
}Automatische toString
Caseklassen krijgen automatisch een leesbare toString die de klassenaam en veldwaarden toont.
Zo worden foutopsporing en logboekregistratie eenvoudig.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p)
}
}Gelijkheid op basis van waarde
Caseklassen worden vergeleken op basis van waarde, niet op basis van referentie. Twee instanties met dezelfde velden zijn gelijk.
Normale klassen zouden in plaats daarvan op identiteit worden vergeleken.
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)
}
}Onveranderlijke velden
Velden van caseklassen zijn standaard val, dus je kunt ze niet opnieuw toewijzen.
Om een aangepaste versie te krijgen, maak je een nieuwe instantie in plaats van de oude te wijzigen.
case class Point(x: Int, y: Int)
object Main {
def main(args: Array[String]): Unit = {
val p = Point(1, 2)
println(p.x)
}
}De copy-methode
Elke caseklasse heeft een copy-methode. Deze maakt een nieuwe instantie, waarbij je alleen de velden kunt wijzigen die je opgeeft.
Dit is de idiomatische manier om onveranderlijke gegevens bij te werken.
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)
}
}Ondersteuning voor patroonvergelijking
Caseklassen werken naadloos samen met match. Je kunt ze deconstrueren door hun velden in een patroon te benoemen.
Dit is een van de belangrijkste redenen om ze te gebruiken.
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)))
}
}Standaardwaarden voor parameters
Net als normale klassen kunnen caseklassen standaardwaarden voor parameters hebben, zodat je deze bij het maken kunt weglaten.
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 toevoegen
Een caseklasse kan, net als elke klasse, eigen methoden in de body hebben. Deze werken met de onveranderlijke velden.
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)
}
}Waarom caseklassen?
Caseklassen bieden je automatisch:
- een beknopte constructor met onveranderlijke velden
- een leesbare
toString - op waarden gebaseerde
equalsenhashCode - een
copy-methode - volwaardige ondersteuning voor patroonvergelijking
Ze vormen de basis voor het modelleren van gegevens in Scala.
Alles samenbrengen
In dit voorbeeld wordt een caseklasse gemaakt, gekopieerd, vergeleken en met patronen vergeleken.
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")
}
}
}Korte controle
Controleer of je caseklassen begrijpt.
Samenvatting
Je hebt geleerd dat een case class onveranderlijke gegevens modelleert met automatisch gegenereerde hulpmiddelen:
- Construeer zonder
new; velden zijn onveranderlijkevals - Gratis
toString, op waarden gebaseerdeequals/hashCode copymaakt aangepaste klonen- Ingebouwde ondersteuning voor patroonherkenning
- Standaardwaarden en aangepaste methoden zijn toegestaan
Leer Scala met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 143
Veelgestelde vragen
Is de les “Case classes” gratis?
Ja — de volledige tekst van “Case classes” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 4 lessen.
Wat leer ik in “Case classes”?
Onveranderlijke gegevensdragers Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?
Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Case classes”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?
Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.