Classes, data classes et objets

Ce que tu vas apprendre

• Déclarer une classe avec ses propriétés et ses méthodes.
• Utiliser une data class pour représenter des données comme une recette.
• Comprendre object et companion object.

Une première classe

class Ingredient(val nom: String, var quantite: Int) {
    fun afficher() {
        println("$quantite x $nom")
    }
}

fun main() {
    val farine = Ingredient("farine", 250)
    farine.quantite = 300
    farine.afficher()   // 300 x farine
}

Une classe est un modèle qui décrit un type d'objet, ici un ingrédient. Une instance est un objet créé à partir de ce modèle.

La liste entre parenthèses après le nom est le constructeur principal. Les paramètres marqués val ou var deviennent des propriétés, c'est-à-dire des valeurs rangées dans l'objet.

On crée une instance sans mot-clé new : Ingredient("farine", 250). On lit une propriété avec un point, et on appelle une méthode (une fonction de la classe) de la même façon.

val donne une propriété en lecture seule, var une propriété modifiable. Choisis val sauf si la valeur doit changer.

Valeurs par défaut

class Recette(val titre: String, var portions: Int = 4) {
    val categorie: String = "plat"
}

val gratin = Recette("Gratin")
println(gratin.portions)   // 4

Un paramètre du constructeur peut avoir une valeur par défaut, comme pour une fonction. On peut aussi déclarer une propriété dans le corps de la classe, avec une valeur initiale.

data class : des données prêtes à l'emploi

data class Recette(val titre: String, val minutes: Int)

fun main() {
    val tarte = Recette("Tarte", 50)
    println(tarte)                     // Recette(titre=Tarte, minutes=50)
    println(tarte == Recette("Tarte", 50))   // true
}

Une data class se déclare avec data. Le compilateur génère pour toi plusieurs fonctions à partir des propriétés du constructeur principal :

• toString() pour un affichage lisible ;
• equals() et hashCode() pour comparer le contenu avec == ;
• copy() pour dupliquer l'objet ;
• componentN(), qui permet la déstructuration.

Le constructeur principal doit avoir au moins un paramètre, et chaque paramètre doit être marqué val ou var.

copy et déstructuration

val tarte = Recette("Tarte", 50)
val rapide = tarte.copy(minutes = 30)
val (titre, minutes) = rapide
println("$titre : $minutes min")   // Tarte : 30 min

copy() crée un nouvel objet en changeant seulement les propriétés indiquées. L'original reste intact.

La déstructuration val (titre, minutes) = rapide répartit les propriétés dans des variables, dans l'ordre de déclaration.

La copie est superficielle : si une propriété contient une liste modifiable, la copie et l'original partagent cette liste. Préfère des données non modifiables.

object : un singleton

object CarnetDeRecettes {
    private val recettes = mutableListOf<String>()

    fun ajouter(titre: String) {
        recettes.add(titre)
    }

    fun nombre() = recettes.size
}

fun main() {
    CarnetDeRecettes.ajouter("Quiche")
    println(CarnetDeRecettes.nombre())   // 1
}

Un object déclare une classe et crée son unique instance en une seule étape. On l'appelle un singleton. On l'utilise directement par son nom, sans le construire.

companion object : des fonctions de classe

class Recette(val titre: String) {
    companion object {
        fun vide() = Recette("Sans titre")
    }
}

val brouillon = Recette.vide()

Un companion object est un objet rangé à l'intérieur d'une classe. Ses fonctions s'appellent avec le nom de la classe, Recette.vide(). On y met souvent des fonctions de fabrique ou des constantes.

À retenir

• Une class décrit un modèle ; ses paramètres val ou var du constructeur deviennent des propriétés.
• On crée une instance sans new et on accède aux membres avec un point.
• Une data class génère toString, equals, hashCode, copy et la déstructuration.
• copy() est superficiel : attention aux listes modifiables partagées.
• object crée un singleton utilisable directement par son nom.
• companion object regroupe les fonctions et constantes rattachées à une classe.