Kotlin Academy · Leçon

Délégation ou héritage

Choisir la composition

Délégation ou héritage est une leçon Kotlin 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Deux façons de réutiliser

L'héritage et la délégation permettent tous deux de réutiliser un comportement. L'héritage signifie qu'une classe est une sorte d'une autre. La délégation signifie qu'une classe possède un collaborateur auquel elle transmet ses appels.

Le conseil classique : préférez la composition à l'héritage.

Exemple d'héritage

Avec l'héritage, une sous-classe étend une classe de base et redéfinit des membres. La classe de base doit être open en Kotlin.

open class Animal {
    open fun sound() = "..."
}

class Dog : Animal() {
    override fun sound() = "woof"
}

fun main() {
    println(Dog().sound())
}

Exemple de délégation

La même réutilisation avec la délégation : le comportement réside dans un membre auquel la classe transmet les appels.

interface Sound { fun sound(): String }
class Bark : Sound { override fun sound() = "woof" }

class Dog(s: Sound) : Sound by s

fun main() {
    println(Dog(Bark()).sound())
}

La classe de base fragile

L’héritage couple étroitement une sous-classe aux détails internes de sa classe parente. Une modification de la base peut casser silencieusement les sous-classes : le problème de la classe de base fragile. La délégation dépend uniquement de l’interface.

Encapsulation

Une sous-classe peut accéder aux membres protégés et redéfinir des points d’extension, en observant les détails de la classe parente. Une classe qui délègue ne voit que l’interface publique, ce qui préserve l’encapsulation.

interface Counter { fun increment(): Int }

class SimpleCounter : Counter {
    private var n = 0
    override fun increment(): Int { n++; return n }
}

class GuardedCounter(private val c: Counter) : Counter by c {
    override fun increment(): Int {
        println("incrementing")
        return c.increment()
    }
}

fun main() {
    val g = GuardedCounter(SimpleCounter())
    println(g.increment())
    println(g.increment())
}

Flexibilité à l’exécution

L’héritage fixe la classe parente au moment de la compilation. La délégation vous permet d’injecter différentes implémentations à l’exécution et facilite les vérifications avec de faux objets.

interface Clock { fun now(): Int }
class RealClock : Clock { override fun now() = 100 }
class FakeClock : Clock { override fun now() = 0 }

class Timer(c: Clock) : Clock by c

fun main() {
    println(Timer(RealClock()).now())
    println(Timer(FakeClock()).now()) // easy to test
}

Plusieurs comportements

Une classe ne peut étendre qu’une seule classe parente, mais elle peut déléguer à plusieurs interfaces. La délégation s’adapte à la combinaison de plusieurs capacités.

interface Walk { fun walk() = "walking" }
interface Swim { fun swim() = "swimming" }
class Walker : Walk
class Swimmer : Swim

class Amphibian : Walk by Walker(), Swim by Swimmer()

fun main() {
    val a = Amphibian()
    println(a.walk() + ", " + a.swim())
}

Quand l’héritage convient

L’héritage reste adapté à une véritable relation est-un au sein d’une hiérarchie stable conçue pour l’extension : familles de types scellées, classes de base de bibliothèques et polymorphisme sur un type abstrait partagé.

sealed class Shape
class Circle(val r: Double) : Shape()
class Square(val s: Double) : Shape()

fun area(shape: Shape) = when (shape) {
    is Circle -> 3.14 * shape.r * shape.r
    is Square -> shape.s * shape.s
}

fun main() {
    println(area(Circle(2.0)))
}

Quand la délégation convient

Choisissez la délégation lorsque vous souhaitez :

Réutiliser un comportement entre des types sans lien
Combiner plusieurs capacités
Limiter le couplage et faciliter les vérifications
Envelopper et décorer des implémentations existantes

Comparaison côte à côte

Héritage : une classe parente, couplage étroit, fixé à la compilation, est-un. Délégation : plusieurs collaborateurs, couplage faible, interchangeable à l’exécution, possède-un. Kotlin rend la délégation peu coûteuse avec by, ce qui fait pencher le choix vers la composition.

Un choix par défaut pratique

Une bonne règle consiste à commencer par la délégation. Ne passez à l’héritage que lorsqu’une véritable hiérarchie stable de relations est-un apparaît. Vos conceptions restent ainsi flexibles et résistantes aux changements.

Vérification rapide

Évaluez votre compréhension de la délégation et de l’héritage.

Récapitulatif

Vous avez comparé les deux approches :

Héritage : est-un, une seule classe parente, couplage étroit
Délégation : possède-un, plusieurs collaborateurs, couplage faible
Privilégiez la composition ; utilisez l’héritage pour les hiérarchies stables de relations est-un

Ensuite : des modèles pratiques de décorateur avec la délégation.

Questions Fréquemment Posées

La leçon « Délégation ou héritage » est-elle gratuite ?

Oui — le texte complet de « Délégation ou héritage » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Délégation ou héritage » ?

Choisir la composition Tu pratiques Kotlin 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 Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin 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 « Délégation ou héritage » ?

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

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

← Retour à Kotlin Academy