Sealed traits
Slutna hierarkier.
Sealed traits är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.
Vad är en trait?
En trait liknar ett gränssnitt: den deklarerar en gemensam typ som andra klasser kan utöka.
Traits låter dig gruppera relaterade typer under ett gemensamt paraply, så att de kan användas utbytbart.
En grundläggande trait
Deklarera en trait med trait och låt sedan klasser eller objekt extends den.
trait Shape
case class Circle(r: Double) extends Shape
case class Square(side: Double) extends Shape
object Main {
def main(args: Array[String]): Unit = {
val s: Shape = Circle(2.0)
println(s)
}
}Vad betyder sealed?
En sealed trait kan bara utökas av typer som deklareras i samma fil.
Detta sluter hierarkin: kompilatorn känner till den fullständiga listan över möjliga undertyper.
sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color
object Main {
def main(args: Array[String]): Unit = {
val c: Color = Green
println(c)
}
}Case objects som varianter
När en variant inte innehåller någon data använder du case object i stället för case class. Det finns alltid bara en instans.
Det passar perfekt för enum-liknande värden.
sealed trait Direction
case object North extends Direction
case object South extends Direction
object Main {
def main(args: Array[String]): Unit = {
val d: Direction = North
println(d)
}
}Blanda objekt och klasser
En sealed trait kan ha både case object-varianter (utan data) och case class-varianter (med data).
sealed trait Event
case object Started extends Event
case class Failed(reason: String) extends Event
object Main {
def main(args: Array[String]): Unit = {
val e: Event = Failed("timeout")
println(e)
}
}Matchning mot en sealed trait
Du matchar mot traiten och hanterar varje variant. Eftersom hierarkin är sealed kan kompilatorn kontrollera att du har täckt alla varianter.
sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color
object Main {
def hex(c: Color): String = c match {
case Red => "#FF0000"
case Green => "#00FF00"
case Blue => "#0000FF"
}
def main(args: Array[String]): Unit = {
println(hex(Green))
}
}Kompilatorvarningar
Om du glömmer en variant i en matchning mot en sealed trait varnar kompilatorn för det saknade fallet.
Detta upptäcker fel när du senare lägger till en ny variant. Vi går igenom detta mer fullständigt i lektionen om uttömmande matchning.
Traits kan deklarera medlemmar
En trait kan deklarera metoder eller fält som alla undertyper delar eller måste implementera.
sealed trait Animal {
def sound: String
}
case object Dog extends Animal { def sound = "Woof" }
case object Cat extends Animal { def sound = "Meow" }
object Main {
def main(args: Array[String]): Unit = {
println(Dog.sound)
println(Cat.sound)
}
}Varför sealed?
Genom att göra en trait sealed får du:
- En känd, sluten mängd undertyper
- Uttömmandekontroll i
match - Säkrare refaktorering när du lägger till varianter
Sealed traits tillsammans med case classes är hur Scala bygger algebraiska datatyper.
Använda hierarkin
Funktioner kan ta emot trait-typen och arbeta med valfri variant genom att skicka vidare med mönstermatchning.
sealed trait Payment
case class Cash(amount: Int) extends Payment
case class Card(number: String) extends Payment
object Main {
def summary(p: Payment): String = p match {
case Cash(a) => s"cash $a"
case Card(n) => s"card ending ${n.takeRight(4)}"
}
def main(args: Array[String]): Unit = {
println(summary(Cash(50)))
println(summary(Card("123456789012")))
}
}Sätta ihop allt
En sealed trait med blandade varianter, som används gemensamt via en funktion som matchar varje fall.
sealed trait Result
case object Pending extends Result
case class Success(value: Int) extends Result
case class Error(msg: String) extends Result
object Main {
def show(r: Result): String = r match {
case Pending => "waiting"
case Success(v) => s"ok: $v"
case Error(m) => s"fail: $m"
}
def main(args: Array[String]): Unit = {
List(Pending, Success(7), Error("boom")).foreach(r => println(show(r)))
}
}Snabbtest
Testa dina kunskaper om sealed traits.
Sammanfattning
Du har lärt dig om sealed traits:
- En
traitdefinierar en gemensam supertyp sealedbegränsar undertyper till samma fil- Använd
case objectför varianter utan data ochcase classför varianter med data - Sealing möjliggör uttömmandekontroll i
match
Lär dig Scala med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 143
Vanliga frågor
Är lektionen ”Sealed traits” gratis?
Ja – hela texten till ”Sealed traits” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.
Vad lär jag mig i ”Sealed traits”?
Slutna hierarkier. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?
Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.
Hur lång tid tar lektionen ”Sealed traits”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?
Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.