Traits scellés
Hiérarchies fermées
Traits scellés est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu’est-ce qu’un trait ?
Un trait ressemble à une interface : il déclare un type commun que d’autres classes peuvent étendre.
Les traits permettent de regrouper des types associés sous une même abstraction afin de les utiliser de manière interchangeable.
Un trait simple
Déclarez un trait avec trait, puis faites en sorte que des classes ou des objets l’étendent avec 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)
}
}Que signifie sealed ?
Un trait sealed ne peut être étendu que par des types déclarés dans le même fichier.
Cela ferme la hiérarchie : le compilateur connaît la liste complète des sous-types possibles.
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)
}
}Les objets case comme variantes
Lorsqu’une variante ne contient aucune donnée, utilisez case object plutôt que case class. Il n’existe alors qu’une seule instance.
C’est parfait pour des valeurs semblables à celles d’une énumération.
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)
}
}Mélanger objets et classes
Un trait sealed peut comporter à la fois des variantes case object (sans données) et des variantes case class (avec des données).
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)
}
}Faire correspondre un trait sealed
Vous faites correspondre le trait et gérez chaque variante. Comme la hiérarchie est sealed, le compilateur peut vérifier que vous les avez toutes couvertes.
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))
}
}Avertissements du compilateur
Si vous oubliez une variante dans une correspondance sur un trait sealed, le compilateur vous avertit qu’un cas manque.
Cela permet de détecter les anomalies lorsque vous ajoutez ensuite une nouvelle variante. Nous étudierons cela en détail dans la leçon sur les correspondances exhaustives.
Les traits peuvent déclarer des membres
Un trait peut déclarer des méthodes ou des champs que tous les sous-types partagent ou doivent implémenter.
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)
}
}Pourquoi utiliser sealed ?
Rendre un trait sealed vous offre :
- Un ensemble connu et fermé de sous-types
- La vérification de l’exhaustivité dans
match - Une refactorisation plus sûre lors de l’ajout de variantes
Les traits sealed associés aux classes case sont la manière dont Scala construit les types de données algébriques.
Utiliser la hiérarchie
Les fonctions peuvent accepter le type du trait et fonctionner avec n’importe quelle variante, en distribuant le traitement par correspondance de motifs.
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")))
}
}Mettre tout ensemble
Un trait sealed avec des variantes mixtes, partagé par une fonction qui fait correspondre chaque cas.
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)))
}
}Vérification rapide
Vérifiez votre compréhension des traits sealed.
Récapitulatif
Vous avez découvert les traits sealed :
traitdéfinit un supertype partagésealedlimite les sous-types au même fichier- Utilisez
case objectpour les variantes sans données etcase classpour celles qui en contiennent - sealed permet de vérifier l’exhaustivité dans
match
Apprends Scala avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 143
Questions Fréquemment Posées
La leçon « Traits scellés » est-elle gratuite ?
Oui — le texte complet de « Traits scellés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Traits scellés » ?
Hiérarchies fermées Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Traits scellés » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.