when exhaustif avec des hiérarchies scellées
Écrivez des expressions when complètes couvrant toutes les variantes scellées.
when exhaustif avec des hiérarchies scellées est une leçon Kotlin Academy 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Expression conditionnelle exhaustive
Une expression when utilisée comme expression doit être exhaustive : toutes les valeurs possibles doivent être traitées. Les hiérarchies scellées permettent au compilateur de le vérifier pour vous.
Expression conditionnelle non exhaustive sur un type ouvert
Pour les classes ordinaires, le compilateur ne peut pas vérifier tous les sous-types : une branche else est donc requise.
open class Shape
class Circle : Shape()
class Square : Shape()
fun describe(s: Shape) = when (s) {
is Circle -> "circle"
is Square -> "square"
else -> "unknown" // required
}
fun main() { println(describe(Circle())) }Expression exhaustive sur un type scellé
Pour une classe scellée, le compilateur connaît tous les sous-types. Aucune branche else n'est nécessaire si chaque cas est couvert.
sealed class Result
class Success(val value: Int) : Result()
class Failure(val msg: String) : Result()
fun describe(r: Result) = when (r) {
is Success -> "ok: ${r.value}"
is Failure -> "err: ${r.msg}"
}
fun main() {
println(describe(Success(42)))
println(describe(Failure("nope")))
}Interface scellée
Les interfaces scellées permettent une vérification d'exhaustivité même lorsque les classes ont besoin de l'héritage multiple.
sealed interface Animal
class Dog : Animal
class Cat : Animal
fun speak(a: Animal) = when (a) {
is Dog -> "woof"
is Cat -> "meow"
}
fun main() {
println(speak(Dog()))
println(speak(Cat()))
}Conversions intelligentes dans les branches
Dans chaque branche is, Kotlin convertit automatiquement la variable vers le type précis : aucune conversion manuelle n'est nécessaire.
sealed class Event
data class Click(val x: Int, val y: Int) : Event()
data class Key(val char: Char) : Event()
fun handle(e: Event) = when (e) {
is Click -> "clicked at (${e.x},${e.y})" // smart-cast
is Key -> "key=${e.char}"
}
fun main() {
println(handle(Click(10, 20)))
println(handle(Key('A')))
}Oublier un cas
Si vous ajoutez ultérieurement une nouvelle variante, chaque expression when exhaustive qui utilise encore le type scellé comme expression cesse de compiler : c'est un excellent filet de sécurité.
sealed class Status
object Idle : Status()
object Running : Status()
// If we add object Done : Status(), every exhaustive when must update.
fun text(s: Status): String = when (s) {
is Idle -> "idle"
is Running -> "running"
}
fun main() { println(text(Idle)) }Types scellés avec des classes de données
Schéma courant : utiliser des classes de données comme variantes d'une hiérarchie scellée.
sealed class UiState {
object Loading : UiState()
data class Success(val data: List<String>) : UiState()
data class Error(val message: String) : UiState()
}
fun render(state: UiState) = when (state) {
UiState.Loading -> "loading..."
is UiState.Success -> "got ${state.data.size} items"
is UiState.Error -> "error: ${state.message}"
}
fun main() {
println(render(UiState.Loading))
println(render(UiState.Success(listOf("a", "b"))))
println(render(UiState.Error("404")))
}Utiliser une expression conditionnelle comme instruction
Lorsqu'elle est utilisée comme instruction (et non comme expression), when n'a pas besoin d'être exhaustive. Mais vous renoncez alors à ce filet de sécurité.
sealed class Cmd
object Start : Cmd()
object Stop : Cmd()
fun execute(c: Cmd) {
// Statement form: no error if incomplete (avoid this style)
when (c) {
Start -> println("started")
Stop -> println("stopped")
}
}
fun main() { execute(Start); execute(Stop) }Forcer la vérification d'exhaustivité d'une instruction
Affectez le résultat de when à une valeur (ou utilisez l'astuce .exhaustive) afin que le compilateur impose le traitement de tous les cas.
sealed class Cmd
object Start : Cmd()
object Stop : Cmd()
fun execute(c: Cmd) {
val handled: Unit = when (c) { // expression context now
Start -> println("started")
Stop -> println("stopped")
}
}
fun main() { execute(Start) }Branches à cas multiples
Regroupez les cas avec des virgules pour partager le même corps entre plusieurs variantes.
sealed class Event
class Click : Event()
class Tap : Event()
class Drag : Event()
fun isPointer(e: Event) = when (e) {
is Click, is Tap, is Drag -> true
}
fun main() { println(isPointer(Tap())) }Types scellés imbriqués
Les hiérarchies scellées peuvent être imbriquées : la vérification d'exhaustivité fonctionne toujours dans les arbres profonds.
sealed class Network {
sealed class Wifi : Network() {
object Open : Wifi()
data class Secured(val ssid: String) : Wifi()
}
object Cellular : Network()
}
fun describe(n: Network) = when (n) {
Network.Wifi.Open -> "open wifi"
is Network.Wifi.Secured -> "secured: ${n.ssid}"
Network.Cellular -> "cellular"
}
fun main() {
println(describe(Network.Wifi.Secured("home")))
println(describe(Network.Cellular))
}Vérification rapide
Quel est le principal avantage d'utiliser when avec des hiérarchies scellées ?
Récapitulatif
Associez les classes et interfaces scellées à when pour garantir l'exhaustivité à la compilation. Les conversions intelligentes simplifient le contenu des branches. Utilisez l'expression comme expression (ou affectez son résultat) pour forcer la vérification : regroupez les cas avec des virgules et imbriquez les types scellés pour représenter un état arborescent.
Questions Fréquemment Posées
La leçon « when exhaustif avec des hiérarchies scellées » est-elle gratuite ?
Oui — le texte complet de « when exhaustif avec des hiérarchies scellées » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « when exhaustif avec des hiérarchies scellées » ?
Écrivez des expressions when complètes couvrant toutes les variantes scellées. Tu pratiques Kotlin Academy 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 Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin Academy 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 « when exhaustif avec des hiérarchies scellées » ?
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 Kotlin Academy ?
Oui. Chaque leçon Kotlin Academy 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.
Toutes les leçons de ce cours
- sealed class ou sealed interface : quand utiliser chacune
- when exhaustif avec des hiérarchies scellées
- Modéliser l’état de l’interface utilisateur avec des classes scellées
- Imbriquer et combiner des hiérarchies scellées