Déclarer une classe simple (propriétés, méthodes)

Introduction : le plan de nos objets

La classe est le concept fondamental de la programmation orientée objet (POO). Elle sert de modèle ou de plan directeur pour créer des objets. Une classe définit la structure et le comportement communs à toutes ses instances (les objets). En Kotlin, la déclaration d'une classe est simple et concise, utilisant le mot-clé `class`.

Dans cette section, nous allons apprendre la syntaxe de base pour déclarer une classe simple. Nous verrons comment y intégrer les deux éléments essentiels qui la composent : les propriétés, qui représentent les données ou l'état d'un objet, et les méthodes (fonctions membres), qui définissent les actions ou le comportement que l'objet peut effectuer.

Syntaxe de base d'une classe

Pour déclarer une classe en Kotlin, on utilise le mot-clé `class` suivi du nom de la classe. Par convention, les noms de classes commencent par une lettre majuscule et suivent le style `PascalCase` (par exemple, `UserProfile`, `NetworkManager`).

Le corps de la classe, où l'on définit ses propriétés et méthodes, est délimité par des accolades `{}`.

// Déclaration minimale d'une classe vide
class Empty

// Déclaration d'une classe avec un corps
class Dog {
    // Le contenu (propriétés et méthodes) viendra ici
}

Cette simple déclaration définit un nouveau type dans notre programme. Nous pouvons ensuite créer des instances (objets) de cette classe, même si pour l'instant notre classe `Dog` est vide et ne fait rien d'utile.

Ajouter de l'état : les propriétés

Les propriétés sont des variables membres qui appartiennent à la classe et définissent l'état de ses objets. Chaque instance de la classe aura sa propre copie de ces propriétés (sauf cas particuliers comme les propriétés d'objets compagnons). On déclare les propriétés à l'intérieur du corps de la classe en utilisant `val` (pour une propriété en lecture seule après initialisation) ou `var` (pour une propriété modifiable).

Kotlin génère automatiquement les mécanismes d'accès sous-jacents (appelés accesseurs : getter pour lire la valeur, et setter pour la modifier dans le cas d'une `var`). Vous interagissez simplement avec la propriété par son nom.

class Dog {
    // Propriété immutable (lecture seule après initialisation)
    val breed: String = "Labrador" // Doit être initialisée

    // Propriété mutable (peut être modifiée)
    var age: Int = 0 // Doit être initialisée

    var name: String? = null // Peut être nullable et initialisée à null
}

fun main() {
    // Création d'une instance (objet) de la classe Dog
    val myDog = Dog()

    // Accès en lecture aux propriétés
    println("Race: ${myDog.breed}")   // Affiche: Race: Labrador
    println("Age initial: ${myDog.age}") // Affiche: Age initial: 0
    println("Nom initial: ${myDog.name}") // Affiche: Nom initial: null

    // Modification d'une propriété 'var'
    myDog.age = 1
    myDog.name = "Buddy"
    println("Nouvel âge: ${myDog.age}") // Affiche: Nouvel âge: 1
    println("Nouveau nom: ${myDog.name}") // Affiche: Nouveau nom: Buddy

    // Tentative de modification d'une propriété 'val' (Erreur !)
    // myDog.breed = "Golden Retriever" // Erreur de compilation: Val cannot be reassigned
}

Les propriétés définissent donc les caractéristiques de chaque chien : sa race (qui ne change pas), son âge (qui peut changer) et son nom (qui peut être défini ou non et changer).

Définir le comportement : les méthodes

Les méthodes sont des fonctions définies à l'intérieur d'une classe. Elles définissent le comportement des objets de cette classe, c'est-à-dire les actions qu'ils peuvent effectuer. Les méthodes peuvent lire et modifier les propriétés de l'objet auquel elles appartiennent (son état interne).

On déclare une méthode en utilisant le mot-clé `fun`, exactement comme pour une fonction standard, mais à l'intérieur du corps de la classe.

class Counter {
    var count: Int = 0 // Propriété stockant l'état

    // Méthode pour incrémenter le compteur
    fun increment() {
        count++ // Modifie la propriété 'count' de cet objet Counter
    }

    // Méthode pour obtenir la valeur actuelle (bien qu'on puisse accéder directement à la propriété)
    fun getCurrentValue(): Int {
        return count // Lit la propriété 'count'
    }

    // Méthode pour réinitialiser
    fun reset() {
        count = 0
    }
}

fun main() {
    val c1 = Counter()
    val c2 = Counter()

    c1.increment() // Appelle la méthode sur l'instance c1
    c1.increment()

    c2.increment() // Appelle la méthode sur l'instance c2

    println("Valeur de c1: ${c1.getCurrentValue()}") // Affiche: Valeur de c1: 2
    println("Valeur de c2: ${c2.count}")        // Affiche: Valeur de c2: 1 (accès direct à la propriété)

    c1.reset()
    println("Valeur de c1 après reset: ${c1.count}") // Affiche: Valeur de c1 après reset: 0
}

Chaque instance (`c1`, `c2`) a son propre état (`count`). Appeler une méthode sur une instance spécifique opère sur l'état de cette instance uniquement.

Instanciation : créer des objets à partir de la classe

Une fois qu'une classe est définie (le plan), vous pouvez créer autant d'instances (d'objets) que vous le souhaitez. L'acte de créer un objet à partir d'une classe s'appelle l'instanciation.

En Kotlin, l'instanciation se fait simplement en appelant ce qui ressemble à un appel de fonction portant le nom de la classe, suivi de parenthèses `()`. Cela invoque le constructeur de la classe (que nous détaillerons ensuite) pour créer et initialiser le nouvel objet.

class Greeter {
    fun sayHello(name: String) {
        println("Hello, $name!")
    }
}

fun main() {
    // Instanciation: création d'un objet 'greeterObject' de la classe 'Greeter'
    val greeterObject = Greeter()

    // Appel d'une méthode sur l'objet créé
    greeterObject.sayHello("Kotlin Developer") // Affiche: Hello, Kotlin Developer!

    // On peut créer plusieurs instances indépendantes
    val anotherGreeter = Greeter()
    // anotherGreeter est un objet différent de greeterObject
}

Chaque appel à `Greeter()` crée un nouvel objet distinct en mémoire, basé sur le plan défini par la classe `Greeter`.

Récapitulatif : la classe comme blueprint

La déclaration d'une classe simple en Kotlin permet de définir un nouveau type structuré :

• On utilise le mot-clé `class` suivi du nom (`PascalCase`).
• Le corps est délimité par `{}`.
• Les propriétés (`val` ou `var`) définissent l'état (données) des objets.
• Les méthodes (`fun`) définissent le comportement (actions) des objets et peuvent interagir avec les propriétés.
• On crée des instances (objets) avec `NomDeLaClasse()`.
• On accède aux propriétés et méthodes d'un objet via l'opérateur point (`.`).

C'est le fondement de la POO, permettant de modéliser des concepts complexes en regroupant données et comportements associés au sein d'une même entité logique.