PricingLoginStart free
Kotlin Academy · Lezione

Annidare e combinare gerarchie sealed

Costruisca macchine a stati complesse annidando i tipi sealed.

Lezione 4 di 413 passaggi

Annidare e combinare gerarchie sealed è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 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 Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Composizione degli alberi di stato

Nella pratica, lo stato presenta spesso più dimensioni. Annidi i tipi sealed o combini gerarchie separate per modellare in modo ordinato domini complessi.

Sealed class annidata

Dichiari i tipi sealed figli all'interno di un tipo sealed esterno. Il compilatore impone comunque l'esaustività sull'intero albero.

sealed class UiState {
    object Loading : UiState()
    sealed class Loaded : UiState() {
        data class Success(val items: List<String>) : Loaded()
        data class Empty(val message: String) : Loaded()
    }
    data class Error(val msg: String) : UiState()
}
fun render(s: UiState) = when (s) {
    UiState.Loading -> "loading"
    is UiState.Loaded.Success -> "${s.items.size} items"
    is UiState.Loaded.Empty -> "empty: ${s.message}"
    is UiState.Error -> "err: ${s.msg}"
}
fun main() {
    println(render(UiState.Loaded.Success(listOf("a", "b"))))
}

Sealed interface per i mixin

Utilizzi sealed interface quando uno stato presenta più aspetti ortogonali, rappresentando ogni aspetto con un'interfaccia diversa.

sealed interface Authenticated
data class User(val id: Int) : Authenticated
object Guest
sealed interface Permission
object Read : Permission
object Write : Permission
fun describe(a: Authenticated, p: Permission): String = when {
    a is User && p is Write -> "user ${a.id} can write"
    a is User -> "user ${a.id} can read"
    else -> "?"
}
fun main() {
    println(describe(User(1), Write))
}

Combinazione delle gerarchie

Passi due valori sealed e scelga in base alla loro combinazione: utilizzi un when con guardie.

sealed class Theme { object Light : Theme(); object Dark : Theme() }
sealed class Lang { object En : Lang(); object Tr : Lang() }
fun greet(theme: Theme, lang: Lang) = when {
    theme is Theme.Dark && lang is Lang.Tr -> "Karanlik Merhaba"
    theme is Theme.Light && lang is Lang.Tr -> "Aydinlik Merhaba"
    theme is Theme.Dark -> "Dark Hello"
    theme is Theme.Light -> "Light Hello"
    else -> "?"
}
fun main() {
    println(greet(Theme.Dark, Lang.Tr))
}

Macchina a stati con varianti annidate

Modelli i flussi di lavoro composti da più passaggi come tipi sealed annidati: ogni passaggio ha le proprie varianti.

sealed class Checkout {
    object Start : Checkout()
    sealed class Payment : Checkout() {
        object Pending : Payment()
        data class Failed(val reason: String) : Payment()
        object Captured : Payment()
    }
    object Shipped : Checkout()
    object Delivered : Checkout()
}
fun describe(c: Checkout) = when (c) {
    Checkout.Start -> "starting"
    Checkout.Payment.Pending -> "awaiting payment"
    is Checkout.Payment.Failed -> "payment failed: ${c.reason}"
    Checkout.Payment.Captured -> "paid"
    Checkout.Shipped -> "shipped"
    Checkout.Delivered -> "delivered"
}
fun main() {
    println(describe(Checkout.Payment.Failed("card declined")))
}

Riutilizzo delle gerarchie sealed tra moduli

È preferibile definire i tipi sealed per modulo. Per la composizione tra moduli, esponga una sealed interface in modo che ogni modulo possa aggiungere le proprie implementazioni.

sealed interface Notification
data class Email(val to: String) : Notification
data class Sms(val phone: String) : Notification
fun send(n: Notification) = when (n) {
    is Email -> "sending email to ${n.to}"
    is Sms -> "texting ${n.phone}"
}
fun main() {
    println(send(Email("a@example.com")))
}

Proprietà di base comuni

Le sealed class possono dichiarare proprietà comuni, che tutti i sottotipi ereditano. In questo modo stato e metadati restano DRY.

sealed class HttpResponse(val code: Int) {
    class Ok(val body: String) : HttpResponse(200)
    class NotFound(val path: String) : HttpResponse(404)
    class ServerError(val cause: String) : HttpResponse(500)
}
fun describe(r: HttpResponse) = "[${r.code}] " + when (r) {
    is HttpResponse.Ok -> r.body
    is HttpResponse.NotFound -> "not found: ${r.path}"
    is HttpResponse.ServerError -> "fail: ${r.cause}"
}
fun main() {
    println(describe(HttpResponse.Ok("hello")))
}

Modellazione di alberi ricorsivi

I tipi sealed descrivono naturalmente strutture ricorsive come gli alberi di espressioni.

sealed class Expr {
    data class Num(val value: Int) : Expr()
    data class Add(val left: Expr, val right: Expr) : Expr()
    data class Mul(val left: Expr, val right: Expr) : Expr()
}
fun eval(e: Expr): Int = when (e) {
    is Expr.Num -> e.value
    is Expr.Add -> eval(e.left) + eval(e.right)
    is Expr.Mul -> eval(e.left) * eval(e.right)
}
fun main() {
    val expr = Expr.Add(Expr.Num(3), Expr.Mul(Expr.Num(4), Expr.Num(5)))
    println(eval(expr)) // 23
}

Combinazione con i generics

I tipi sealed possono essere generici e consentono di creare contenitori di risultati tipizzati come Result<T>.

sealed class ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>()
    data class Failure(val message: String) : ApiResult<Nothing>()
}
fun handle(r: ApiResult<String>) = when (r) {
    is ApiResult.Success -> "got ${r.data}"
    is ApiResult.Failure -> "err: ${r.message}"
}
fun main() {
    println(handle(ApiResult.Success("hi")))
    println(handle(ApiResult.Failure("nope")))
}

Anti-pattern: annidamento eccessivo

Un annidamento profondo nasconde l'intento. Se un albero sealed supera i 2 livelli di profondità, valuti la possibilità di appiattirlo o di estrarre i sottoalberi in file propri.

sealed class Top {
    sealed class Mid : Top() {
        sealed class Deep : Mid() {
            object Leaf : Deep()
        }
    }
}
fun main() {
    val l = Top.Mid.Deep.Leaf
    println(l::class.simpleName)
}

Combinazione tramite composizione

Quando due dimensioni dello stato sono indipendenti, preferisca la composizione (una data class che racchiude due valori sealed) alle gerarchie profondamente annidate.

sealed class Loading { object Active : Loading(); object Idle : Loading() }
sealed class Auth { data class Signed(val id: Int) : Auth(); object Anon : Auth() }
data class AppState(val loading: Loading, val auth: Auth)
fun main() {
    val s = AppState(Loading.Active, Auth.Signed(1))
    println(s)
}

Verifica rapida

Qual è l'approccio consigliato quando due dimensioni dello stato sono indipendenti?

Rispondi nella lezione interattiva

Riepilogo

Annidi i tipi sealed per rappresentare stati strutturati ad albero; combini le gerarchie sealed indipendenti tramite composizione (una data class contenitore). Aggiunga proprietà comuni a una base sealed, utilizzi i generics per risultati tipizzati e modelli naturalmente le strutture ricorsive. Mantenga poco profondo l'annidamento.

Gratis per iniziare

Impara Kotlin 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
51
Lezioni
203
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «Annidare e combinare gerarchie sealed» è gratuita?

Sì — il testo completo di «Annidare e combinare gerarchie 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 Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Annidare e combinare gerarchie sealed»?

Costruisca macchine a stati complesse annidando i tipi sealed. Eserciti Kotlin Academy 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 Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Annidare e combinare gerarchie 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 Kotlin Academy?

Sì. Ogni lezione Kotlin Academy 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.

Tutte le lezioni di questo corso

  1. sealed class e sealed interface: quando usare ciascuna
  2. when esaustivo con gerarchie sealed
  3. Modellare lo stato dell'interfaccia con le sealed class
  4. Annidare e combinare gerarchie sealed
← Torna a Kotlin Academy