Les `data class` pour les données (gain de temps)

Le problème : le code répétitif des classes de données

En programmation, nous créons très souvent des classes dont le but principal est simplement de contenir des données. Pensez à des classes comme `User`, `Point`, `Configuration`, `ApiResult`, etc. Ces classes ont généralement des propriétés, mais peu ou pas de comportement spécifique (méthodes).

Pour que ces classes de données se comportent correctement dans divers scénarios (utilisation dans des collections comme `Set` ou comme clés de `Map`, comparaison d'instances, affichage pour le débogage), il est essentiel d'implémenter correctement plusieurs méthodes standards :

• `equals()` : Pour comparer deux instances en fonction de la valeur de leurs propriétés (égalité structurelle) plutôt que de leur référence mémoire.
• `hashCode()` : Pour générer un code de hachage basé sur les propriétés, nécessaire pour les performances dans les collections basées sur le hachage (`HashSet`, `HashMap`). Doit être cohérent avec `equals()` (si `a.equals(b)`, alors `a.hashCode()` doit être égal à `b.hashCode()`).
• `toString()` : Pour obtenir une représentation textuelle lisible de l'objet et de ses propriétés, utile pour le logging et le débogage.

Ecrire ces méthodes manuellement pour chaque classe de données est fastidieux, répétitif et source d'erreurs. Oublier de mettre à jour `equals`/`hashCode` après avoir ajouté une propriété est un bug classique. Kotlin propose une solution élégante pour éliminer complètement ce code boilerplate : les data classes.

La solution Kotlin : `data class`

En ajoutant simplement le mot-clé `data` devant la déclaration d'une classe, vous demandez au compilateur Kotlin de générer automatiquement un ensemble de méthodes standards utiles, basées sur les propriétés déclarées dans le constructeur primaire.

Syntaxe :

data class NomDeLaClasse(val prop1: Type1, var prop2: Type2, ...) {
    // Le corps est optionnel, peut contenir d'autres propriétés ou méthodes,
    // mais elles ne seront PAS prises en compte par les méthodes générées.
}

• Le constructeur primaire doit avoir au moins un paramètre.
• Tous les paramètres du constructeur primaire doivent être marqués comme `val` ou `var`.
• Les data classes ne peuvent pas être `abstract`, `open`, `sealed` ou `inner`.

Les méthodes générées automatiquement

Lorsque vous déclarez une `data class`, le compilateur génère pour vous :

• `equals(other: Any?): Boolean` : Implémentation structurelle basée sur toutes les propriétés du constructeur primaire. Deux instances sont égales si toutes leurs propriétés correspondantes (du constructeur primaire) sont égales.
• `hashCode(): Int` : Implémentation cohérente avec `equals()`, basée sur les hashCodes des propriétés du constructeur primaire.
• `toString(): String` : Implémentation lisible affichant le nom de la classe et les valeurs de toutes les propriétés du constructeur primaire (par exemple, `User(name=Alice, age=30)`).
• `componentN()` : Une fonction `componentN()` pour chaque propriété du constructeur primaire, dans l'ordre de déclaration (`component1()` pour la première propriété, `component2()` pour la seconde, etc.). Ces fonctions sont utilisées pour la destructuration (voir section suivante).
• `copy(...)` : Une méthode très pratique pour créer une copie d'une instance, tout en permettant de modifier optionnellement certaines propriétés lors de la copie.

Illustrons avec un exemple :

data class SimpleUser(val name: String, val age: Int)

fun main() {
    val user1 = SimpleUser("Alice", 30)
    val user2 = SimpleUser("Alice", 30)
    val user3 = SimpleUser("Bob", 25)

    // toString() généré
    println(user1) // Affiche: SimpleUser(name=Alice, age=30)

    // equals() généré (basé sur les propriétés)
    println("user1 == user2: ${user1 == user2}") // Affiche: user1 == user2: true
    println("user1 == user3: ${user1 == user3}") // Affiche: user1 == user3: false

    // hashCode() généré (cohérent avec equals)
    println("hashCode user1: ${user1.hashCode()}")
    println("hashCode user2: ${user2.hashCode()}") // Même hashCode que user1
    println("hashCode user3: ${user3.hashCode()}") // hashCode différent

    // Utilisation dans un Set (grâce à equals/hashCode)
    val userSet = setOf(user1, user2, user3)
    println("Set d'utilisateurs: $userSet") // Affiche: Set d'utilisateurs: [SimpleUser(name=Alice, age=30), SimpleUser(name=Bob, age=25)] (user2 n'est pas ajouté car égal à user1)

    // copy() généré
    val olderAlice = user1.copy(age = 31) // Copie user1 mais change l'âge
    val sameAsUser3 = user3.copy()      // Copie exacte
    println(olderAlice) // Affiche: SimpleUser(name=Alice, age=31)
    println(sameAsUser3) // Affiche: SimpleUser(name=Bob, age=25)
    println("user3 == sameAsUser3: ${user3 == sameAsUser3}") // Affiche: user3 == sameAsUser3: true
}

Tout ce comportement standard est obtenu gratuitement, juste en ajoutant le mot-clé `data` !

Déclarations de déstructuration (`componentN`)

Les fonctions `componentN()` générées automatiquement permettent une syntaxe très pratique appelée déclaration de déstructuration. Elle permet d'extraire les valeurs des propriétés d'une instance de data class directement dans des variables distinctes.

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

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

    // Déclaration de déstructuration
    // Appelle myPoint.component1() pour initialiser 'currentX'
    // Appelle myPoint.component2() pour initialiser 'currentY'
    val (currentX, currentY) = myPoint

    println("Coordonnée X: $currentX") // Affiche: Coordonnée X: 10
    println("Coordonnée Y: $currentY") // Affiche: Coordonnée Y: 20

    // Utile pour itérer sur des maps
    val userAges = mapOf("Alice" to 30, "Bob" to 25)
    for ((name, age) in userAges) { // Déstructure chaque Pair (Entry) de la map
        println("$name a $age ans")
    }
    // Affiche:
    // Alice a 30 ans
    // Bob a 25 ans
}

La déstructuration rend le code qui manipule les données contenues dans ces objets beaucoup plus lisible.

La méthode `copy()` : immutabilité et modification

La méthode `copy()` générée est particulièrement utile lorsqu'on travaille avec des objets immutables (dont les propriétés sont déclarées avec `val`). Comme on ne peut pas modifier directement les propriétés d'un objet immutable, `copy()` fournit un moyen simple de créer une nouvelle instance qui est une copie de l'originale, mais avec certaines propriétés modifiées.

Elle accepte des arguments nommés correspondant aux propriétés du constructeur primaire. Seules les propriétés pour lesquelles vous fournissez une nouvelle valeur seront changées ; les autres conserveront la valeur de l'instance originale.

data class Book(val title: String, val author: String, val year: Int)

fun main() {
    val book1 = Book("Kotlin in Action", "Dmitry Jemerov", 2017)

    // Créer une copie avec seulement l'année modifiée
    val book2 = book1.copy(year = 2020) 

    // Créer une copie avec titre et auteur modifiés
    val book3 = book1.copy(title = "Effective Kotlin", author = "Marcin Moskala")

    println(book1) // Affiche: Book(title=Kotlin in Action, author=Dmitry Jemerov, year=2017)
    println(book2) // Affiche: Book(title=Kotlin in Action, author=Dmitry Jemerov, year=2020)
    println(book3) // Affiche: Book(title=Effective Kotlin, author=Marcin Moskala, year=2017)
}

Cette méthode facilite grandement la création de nouvelles versions d'un état immutable sans avoir à reconstruire manuellement tout l'objet.

Quand utiliser les `data class` ?

Utilisez les `data class` principalement pour les classes dont le but premier est de contenir des données. Les cas d'usage typiques incluent :

• DTO (Data Transfer Objects) : Pour transférer des données entre différentes couches d'une application ou via des API.
• Value Objects : Pour représenter des concepts dont l'identité est définie par leurs attributs (comme une couleur, une date, une coordonnée).
• Modèles de données simples : Pour représenter des entités comme des utilisateurs, produits, paramètres, etc., où le comportement standard (comparaison, affichage) est suffisant.
• Représentation d'état : Dans des architectures comme MVI (Model-View-Intent), les états de l'interface utilisateur sont souvent modélisés avec des data classes.

N'utilisez pas `data class` si :

• L'identité de l'objet est plus importante que son contenu (par exemple, des gestionnaires de threads, des connexions réseau où deux instances ne sont jamais considérées comme égales même si leurs propriétés sont identiques).
• La classe a un comportement complexe et l'égalité ne doit pas dépendre uniquement des propriétés du constructeur primaire.
• Vous avez besoin d'héritage complexe (car les data classes ne peuvent pas être `open`).

Récapitulatif : la puissance des `data class`

Les `data class` sont une fonctionnalité extrêmement utile et idiomatique de Kotlin :

• Elles réduisent drastiquement le code boilerplate pour les classes porteuses de données.
• Elles génèrent automatiquement `equals()`, `hashCode()`, `toString()`, `componentN()`, et `copy()` basés sur les propriétés du constructeur primaire.
• Elles assurent un comportement standardisé et correct pour la comparaison, le hachage et l'affichage.
• Elles activent les déclarations de déstructuration pour un accès facile aux données.
• La méthode `copy()` facilite le travail avec des objets immutables.

Utilisez-les à bon escient pour rendre votre code plus concis, plus lisible et moins sujet aux erreurs lors de la modélisation de vos données.