Kotlin Academy · Leçon

Délégation à des membres

Composer un comportement

Leçon 2 sur 413 étapes

Délégation à des membres est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Composer un comportement

Les objets réels doivent souvent combiner plusieurs capacités. Au lieu d'hériter de plusieurs sources, vous pouvez déléguer chaque capacité à un objet membre dédié.

Deux rôles, une classe

Supposons qu'une classe doive à la fois lire et écrire. Définissez deux interfaces et déléguez chacune à sa propre implémentation.

interface Reader { fun read(): String }
interface Writer { fun write(s: String): String }

class FileReader : Reader { override fun read() = "contents" }
class FileWriter : Writer { override fun write(s: String) = "wrote " + s }

class FileIO(r: Reader, w: Writer) : Reader by r, Writer by w

fun main() {
    val io = FileIO(FileReader(), FileWriter())
    println(io.read())
    println(io.write("data"))
}

Plusieurs délégués

Une classe peut déléguer plusieurs interfaces à la fois, chacune à un membre différent. La classe compose leurs comportements sans héritage.

interface Logger { fun log(m: String): String }
interface Validator { fun valid(m: String): Boolean }

class ConsoleLogger : Logger { override fun log(m: String) = "LOG: " + m }
class LengthValidator : Validator { override fun valid(m: String) = m.isNotEmpty() }

class Service(l: Logger, v: Validator) : Logger by l, Validator by v

fun main() {
    val s = Service(ConsoleLogger(), LengthValidator())
    println(s.valid("hi"))
    println(s.log("started"))
}

Le délégué stocké comme membre

Lorsque vous devez faire référence au délégué dans des redéfinitions, conservez-le comme propriété du constructeur. La même instance sert à la fois au relais et à votre code personnalisé.

interface Cache { fun get(k: String): String }

class MapCache : Cache {
    override fun get(k: String) = "value-of-" + k
}

class TracingCache(private val inner: Cache) : Cache by inner {
    override fun get(k: String): String {
        println("lookup " + k)
        return inner.get(k)
    }
}

fun main() {
    println(TracingCache(MapCache()).get("id"))
}

Mélanger délégation et état propre

Une classe qui délègue peut ajouter ses propres propriétés et méthodes aux côtés des membres relayés, enrichissant ainsi l'objet composé.

interface Engine { fun start(): String }
class V8 : Engine { override fun start() = "vroom" }

class Car(e: Engine) : Engine by e {
    var doors = 4
    fun honk() = "beep"
}

fun main() {
    val c = Car(V8())
    println(c.start())
    println(c.honk())
    println(c.doors)
}

Permuter les implémentations

Comme le délégué n'est qu'un membre, vous pouvez construire la même enveloppe avec différentes implémentations sous-jacentes et choisir le comportement à l'exécution.

interface Notifier { fun send(msg: String): String }
class EmailNotifier : Notifier { override fun send(msg: String) = "email: " + msg }
class SmsNotifier : Notifier { override fun send(msg: String) = "sms: " + msg }

class Alerts(n: Notifier) : Notifier by n

fun main() {
    println(Alerts(EmailNotifier()).send("hi"))
    println(Alerts(SmsNotifier()).send("hi"))
}

Déléguer à une propriété

L'expression qui suit le mot-clé de délégation peut être n'importe quelle expression évaluée une seule fois, y compris un appel de constructeur. Il ne s'agit pas nécessairement d'un paramètre.

interface Greeter { fun greet() = "hi" }
class DefaultGreeter : Greeter

class Page : Greeter by DefaultGreeter()

fun main() {
    println(Page().greet())
}

Éviter le problème du diamant

L'héritage multiple de comportements est impossible avec les classes, mais déléguer plusieurs interfaces à des membres distincts permet de contourner proprement le problème classique du diamant.

interface A { fun a() = "A" }
interface B { fun b() = "B" }
class AImpl : A
class BImpl : B

class Combined : A by AImpl(), B by BImpl()

fun main() {
    val c = Combined()
    println(c.a() + c.b())
}

Concevoir pour la composition

Pour bien composer :

Définissez de petites interfaces spécialisées
Fournissez des implémentations réutilisables
Déléguez chaque rôle dans la classe qui compose

Les classes restent ainsi flexibles et faciles à tester.

Récapitulatif de la délégation aux membres

Déléguer à des objets membres permet à une classe d'assembler un comportement à partir de composants. Vous pouvez combiner de nombreuses interfaces, redéfinir certains éléments, remplacer les implémentations et ajouter votre propre état, le tout sans héritage.

Ensuite : une comparaison directe

Vous avez constaté la flexibilité de la délégation. La prochaine leçon compare directement la délégation et l'héritage, afin que vous sachiez quand choisir l'un ou l'autre.

Vérification rapide

Vérifiez votre compréhension de la délégation aux membres.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris la délégation aux membres :

Déléguer plusieurs interfaces à des objets distincts
Redéfinir certains éléments et ajouter son propre état
Remplacer les implémentations lors de la construction
Éviter les problèmes de l'héritage multiple

Ensuite : délégation ou héritage.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Délégation à des membres » est-elle gratuite ?

Oui — le texte complet de « Délégation à des membres » 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 à des membres » ?

Composer un comportement 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 2 sur 4.

Combien de temps prend la leçon « Délégation à des membres » ?

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