0Pricing
Android Academy · Lezione

Data class e sealed class

Usare le data class per l'uguaglianza basata sui valori e copy() e le sealed class per gerarchie di tipi esaustive e una modellazione chiara degli stati.

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

Che cosa sono le classi di dati?

Una data class in Kotlin è una classe il cui scopo principale è contenere dati. Il compilatore genera automaticamente per Lei metodi utili:

  • equals() — confronta due istanze per valore
  • hashCode() — hash coerente basato sulle proprietà
  • toString() — rappresentazione testuale leggibile
  • copy() — crea una copia modificata
  • Supporto alla destrutturazione

Dichiarare una data class

Aggiunga la parola chiave data prima di class. Tutte le proprietà devono trovarsi nel costruttore primario:

data class User(val id: Int, val name: String, val email: String)

fun main() {
    val u1 = User(1, "Alice", "alice@example.com")
    val u2 = User(1, "Alice", "alice@example.com")

    println(u1)          // User(id=1, name=Alice, email=alice@example.com)
    println(u1 == u2)    // true  (value equality)
    println(u1 === u2)   // false (different objects)
}

copy() — Modificare un campo

copy() crea una nuova istanza con alcune proprietà modificate. L'originale non viene modificato (immutabilità):

data class Product(val name: String, val price: Double, val inStock: Boolean)

fun main() {
    val original = Product("Laptop", 999.0, true)

    // Only change the price; keep everything else
    val onSale = original.copy(price = 799.0)

    println(original)  // Product(name=Laptop, price=999.0, inStock=true)
    println(onSale)    // Product(name=Laptop, price=799.0, inStock=true)
}

Dichiarazioni destrutturate

Le data class supportano la destrutturazione: è possibile suddividere le proprietà in variabili usando le funzioni componentN() generate dal compilatore:

data class Point(val x: Int, val y: Int)

fun main() {
    val point = Point(10, 20)

    // Destructure into separate variables
    val (x, y) = point
    println("x=$x, y=$y")   // x=10, y=20

    // Also works in for loops with maps
    val scores = mapOf("Alice" to 95, "Bob" to 88)
    for ((name, score) in scores) {
        println("$name: $score")
    }
}

Che cosa sono le sealed class?

Una sealed class è una gerarchia di classi limitata: tutte le sottoclassi devono essere definite nello stesso file. In questo modo l'insieme dei tipi possibili è noto in fase di compilazione.

Usi le sealed class per rappresentare un insieme finito di stati, ad esempio risultati di rete, stati dell'interfaccia utente o eventi di navigazione.

Sintassi delle sealed class

Dichiari le sottoclassi direttamente all'interno della classe o nello stesso file:

sealed class NetworkResult<out T> {
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val message: String, val code: Int = 0) : NetworkResult<Nothing>()
    object Loading : NetworkResult<Nothing>()
}

fun handle(result: NetworkResult<String>) {
    when (result) {
        is NetworkResult.Success -> println("Data: ${result.data}")
        is NetworkResult.Error  -> println("Error ${result.code}: ${result.message}")
        NetworkResult.Loading   -> println("Loading...")
    }
}

Sealed class + when (esaustivo)

Il punto di forza delle sealed class: when è esaustivo. Il compilatore impone di gestire ogni sottotipo, evitando casi dimenticati:

sealed class UiState {
    object Loading : UiState()
    data class Success(val message: String) : UiState()
    data class Error(val error: String) : UiState()
}

fun render(state: UiState): String = when (state) {
    is UiState.Loading      -> "Showing spinner"
    is UiState.Success      -> "Show: ${state.message}"
    is UiState.Error        -> "Error: ${state.error}"
    // Compiler error if you remove any branch!
}

fun main() {
    println(render(UiState.Loading))
    println(render(UiState.Success("Loaded!")))
}

Sealed class e enum a confronto

Entrambe rappresentano un insieme fisso di valori, ma:

  • Enum — ogni costante è una singola istanza, senza dati aggiuntivi per variante
  • Sealed class — ogni variante può contenere dati diversi ed essere una classe o un object

Usi enum quando le varianti non richiedono dati. Usi una sealed class quando le varianti richiedono proprietà diverse.

Dichiarazioni object (singleton)

object crea un singleton: una sola istanza, creata in modo differito e sicura per l'uso con più thread:

object AppConfig {
    const val BASE_URL = "https://api.example.com"
    const val TIMEOUT = 30L

    fun buildUrl(path: String) = "$BASE_URL/$path"
}

fun main() {
    println(AppConfig.BASE_URL)          // https://api.example.com
    println(AppConfig.buildUrl("users")) // https://api.example.com/users
}

Companion object

Un companion object si trova all'interno di una classe e fornisce membri a livello di classe (come static in Java). Viene comunemente usato per i metodi factory:

class Token private constructor(val value: String) {
    companion object {
        fun create(raw: String): Token {
            val cleaned = raw.trim()
            require(cleaned.isNotEmpty()) { "Token must not be blank" }
            return Token(cleaned)
        }
    }
}

fun main() {
    val token = Token.create("  abc123  ")
    println(token.value)  // abc123
}

Data class in un'app reale

Combini le data class con le sealed class per modellare gli stati in modo chiaro:

data class Post(val id: Int, val title: String, val body: String)

sealed class PostState {
    object Loading : PostState()
    data class Loaded(val posts: List<Post>) : PostState()
    data class Failed(val reason: String) : PostState()
}

fun showState(state: PostState) = when (state) {
    PostState.Loading        -> println("Fetching posts...")
    is PostState.Loaded      -> println("${state.posts.size} posts loaded")
    is PostState.Failed      -> println("Failed: ${state.reason}")
}

fun main() {
    showState(PostState.Loaded(listOf(
        Post(1, "Hello", "World"),
        Post(2, "Kotlin", "Rocks")
    )))
}

Verifica rapida

Quale affermazione descrive meglio ciò che distingue le sealed class dalle normali classi astratte?

Riepilogo: data class e sealed class

Ora dispone di due potenti strumenti di Kotlin:

  • data class — uguaglianza basata sui valori, copy(), destrutturazione, toString() generato automaticamente
  • sealed class — gerarchia finita di tipi, when esaustivo, ogni variante può contenere i propri dati
  • object — singleton, companion object per i metodi factory

Insieme, questi pattern sostituiscono il codice ripetitivo di Java e consentono di modellare gli stati in modo chiaro e sicuro.

Domande Frequenti

La lezione «Data class e sealed class» è gratuita?

Sì — il testo completo di «Data class e sealed class» è 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 Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.

Cosa imparerò in «Data class e sealed class»?

Usare le data class per l'uguaglianza basata sui valori e copy() e le sealed class per gerarchie di tipi esaustive e una modellazione chiara degli stati. Eserciti Android 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 Android Academy?

Non è richiesta alcuna esperienza precedente. Android 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 3 di 4.

Quanto tempo richiede la lezione «Data class e sealed class»?

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 Android Academy?

Sì. Ogni lezione Android 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. Sicurezza rispetto ai valori null
  2. Classi e oggetti
  3. Data class e sealed class
  4. Extension function e higher-order function
← Torna a Android Academy