0Pricing
Android Academy · Leçon

Classes de données et classes scellées

Utilisez les classes de données pour l’égalité fondée sur les valeurs et copy(), ainsi que les classes scellées pour des hiérarchies de types exhaustives et une modélisation claire des états.

Classes de données et classes scellées est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Que sont les classes de données ?

En Kotlin, une classe de données est une classe dont le rôle principal est de contenir des données. Le compilateur génère automatiquement pour vous des méthodes utiles :

  • equals() — comparer deux instances par leur valeur
  • hashCode() — hachage cohérent fondé sur les propriétés
  • toString() — représentation textuelle lisible
  • copy() — créer une copie modifiée
  • Prise en charge de la déstructuration

Déclarer une classe de données

Ajoutez le mot-clé data avant class. Toutes les propriétés doivent se trouver dans le constructeur primaire :

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() — Modifier un champ

copy() crée une nouvelle instance dont certaines propriétés sont modifiées. L'originale n'est pas modifiée (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)
}

Déclarations par décomposition

Les classes de données prennent en charge la décomposition — décompactez les propriétés dans des variables à l'aide des fonctions componentN() générées par le compilateur :

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")
    }
}

Que sont les classes scellées ?

Une classe scellée est une hiérarchie de classes restreinte : toutes les sous-classes doivent être définies dans le même fichier. L'ensemble des types possibles est ainsi connu lors de la compilation.

Utilisez les classes scellées pour représenter un ensemble fini d'états, comme les résultats réseau, les états de l'interface utilisateur ou les événements de navigation.

Syntaxe d'une classe scellée

Déclarez les sous-classes directement à l'intérieur ou dans le même fichier :

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...")
    }
}

Classe scellée + when (exhaustif)

La puissance des classes scellées : when est exhaustif. Le compilateur vous oblige à gérer chaque sous-type : aucun cas n'est oublié :

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!")))
}

Classe scellée ou énumération

Les deux représentent un ensemble fixe de valeurs, mais :

  • Énumération — chaque constante est une instance unique, sans données supplémentaires par variante
  • Classe scellée — chaque variante peut transporter des données différentes et être une classe ou un objet

Utilisez une énumération lorsque les variantes ne nécessitent aucune donnée. Utilisez une classe scellée lorsque les variantes nécessitent des propriétés différentes.

Déclarations d'objets (instances uniques)

object crée une instance unique : une seule instance, créée à la demande et sûre pour les threads :

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
}

Objets compagnons

Un objet compagnon se trouve à l'intérieur d'une classe et fournit des membres de niveau classe (comme static en Java). Il est souvent utilisé pour les méthodes de fabrique :

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
}

Classes de données dans une véritable application

Combinez les classes de données et les classes scellées pour modéliser clairement les états :

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")
    )))
}

Vérification rapide

Quelle affirmation décrit le mieux ce qui distingue les classes scellées des classes abstraites classiques ?

Récapitulatif&nbsp;: classes de données et classes scellées

Vous disposez désormais de deux outils Kotlin puissants :

  • classe de données — égalité fondée sur la valeur, copy(), décomposition, toString() généré automatiquement
  • classe scellée — hiérarchie de types finie, when exhaustif, chaque variante peut transporter ses propres données
  • objet — instance unique, objets compagnons pour les méthodes de fabrique

Ensemble, ces mécanismes remplacent le code répétitif de Java et permettent une modélisation claire et sûre des états.

Questions Fréquemment Posées

La leçon « Classes de données et classes scellées » est-elle gratuite ?

Oui — le texte complet de « Classes de données et classes 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 Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Classes de données et classes scellées » ?

Utilisez les classes de données pour l’égalité fondée sur les valeurs et copy(), ainsi que les classes scellées pour des hiérarchies de types exhaustives et une modélisation claire des états. Tu pratiques Android 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 Android Academy ?

Aucune expérience préalable n'est requise. Android 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 3 sur 4.

Combien de temps prend la leçon « Classes de données et classes 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 Android Academy ?

Oui. Chaque leçon Android 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

  1. Sécurité vis-à-vis des valeurs nulles
  2. Classes et objets
  3. Classes de données et classes scellées
  4. Fonctions d’extension et fonctions d’ordre supérieur
← Retour à Android Academy