Trait sealed
Gerarchie chiuse
Trait sealed è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Che cos'è un trait?
Un trait è simile a un'interfaccia: dichiara un tipo comune che altre classi possono estendere.
I trait permettono di raggruppare tipi correlati sotto un'unica categoria, così da poterli utilizzare in modo intercambiabile.
Un trait di base
Dichiari un trait con trait, quindi fai in modo che classi o oggetti lo extends.
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)
}
}Che cosa significa sealed?
Un trait sealed può essere esteso solo da tipi dichiarati nello stesso file.
In questo modo la gerarchia è chiusa: il compilatore conosce l'elenco completo dei possibili sottotipi.
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 object come varianti
Quando una variante non contiene dati, utilizzi case object invece di case class. Esiste sempre una sola istanza.
È perfetto per rappresentare valori simili a quelli di un enum.
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)
}
}Combinare oggetti e classi
Un trait sealed può avere sia varianti case object (senza dati) sia varianti case class (con dati).
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)
}
}Eseguire il matching su un trait sealed
Esegue il matching sul trait e gestisce ogni variante. Poiché la gerarchia è sealed, il compilatore può verificare che siano state coperte tutte.
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))
}
}Avvisi del compilatore
Se dimentica una variante in un match su un trait sealed, il compilatore segnala il caso mancante.
Questo permette di intercettare i bug quando in seguito aggiunge una nuova variante. Approfondiremo completamente questo argomento nella lezione sul matching esaustivo.
I trait possono dichiarare membri
Un trait può dichiarare metodi o campi condivisi da tutti i sottotipi o che tutti i sottotipi devono implementare.
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)
}
}Perché usare sealed?
Rendere sealed un trait offre:
- Un insieme noto e chiuso di sottotipi
- La verifica dell'esaustività in
match - Un refactoring più sicuro quando si aggiungono varianti
I trait sealed insieme alle case class sono il modo in cui Scala costruisce i tipi di dati algebrici.
Utilizzare la gerarchia
Le funzioni possono accettare il tipo del trait e lavorare con qualsiasi variante, effettuando il dispatch tramite pattern matching.
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")))
}
}Mettere insieme i concetti
Un trait sealed con varianti miste, condiviso tramite una funzione che esegue il matching su ogni caso.
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)))
}
}Verifica rapida
Verifichi la Sua comprensione dei trait sealed.
Riepilogo
Ha imparato a conoscere i trait sealed:
- Un
traitdefinisce un supertipo condiviso sealedlimita i sottotipi allo stesso file- Utilizzi
case objectper le varianti senza dati ecase classper quelle con dati - Sealing abilita la verifica dell'esaustività in
match
Impara Scala con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 143
Domande Frequenti
La lezione «Trait sealed» è gratuita?
Sì — il testo completo di «Trait sealed» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Trait sealed»?
Gerarchie chiuse Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Trait sealed»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.