Kotlin Academy · Leçon

Modèles pratiques

Décorateurs avec délégation

Modèles pratiques est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Le modèle décorateur

Un décorateur enveloppe un objet pour lui ajouter un comportement tout en conservant la même interface. Le mot-clé by de Kotlin rend les décorateurs très simples : transmettez tout et redéfinissez les parties que vous enrichissez.

Un composant de base

Nous commençons par une source de données simple. Les décorateurs l’envelopperont.

interface DataSource {
    fun fetch(): String
}

class NetworkSource : DataSource {
    override fun fetch() = "raw-data"
}

fun main() {
    println(NetworkSource().fetch())
}

Un décorateur de journalisation

Le décorateur délègue à la source enveloppée et ajoute de la journalisation autour de l’appel qui l’intéresse.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String {
        println("fetching...")
        val result = inner.fetch()
        println("done")
        return result
    }
}

fun main() {
    println(LoggingSource(NetworkSource()).fetch())
}

Un décorateur de mise en cache

Un autre décorateur met en cache le premier résultat afin que les appels répétés ignorent la source sous-jacente.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var cached: String? = null
    override fun fetch(): String {
        return cached ?: inner.fetch().also { cached = it }
    }
}

fun main() {
    val s = CachingSource(NetworkSource())
    println(s.fetch())
    println(s.fetch()) // served from cache
}

Empiler les décorateurs

Comme chaque décorateur est lui-même un DataSource, vous pouvez les empiler. L’ordre compte : l’enveloppe externe entoure l’interne.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String { println("log"); return inner.fetch() }
}
class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var c: String? = null
    override fun fetch() = c ?: inner.fetch().also { c = it }
}

fun main() {
    val s = LoggingSource(CachingSource(NetworkSource()))
    println(s.fetch())
    println(s.fetch())
}

Un décorateur de validation

Les décorateurs peuvent également contrôler les entrées. Ici, un décorateur valide les données avant de déléguer au composant réel.

interface Processor { fun process(input: String): String }
class UpperProcessor : Processor { override fun process(input: String) = input.uppercase() }

class ValidatingProcessor(private val inner: Processor) : Processor by inner {
    override fun process(input: String): String {
        require(input.isNotBlank()) { "empty input" }
        return inner.process(input)
    }
}

fun main() {
    println(ValidatingProcessor(UpperProcessor()).process("hello"))
}

Enveloppe de collection en lecture seule

La délégation facilite la création d’enveloppes d’adaptation. Ici, nous enveloppons une liste et ajoutons une méthode personnalisée de résumé tout en transmettant toutes les opérations de liste.

class SummarizedList(private val inner: List<Int>) : List<Int> by inner {
    fun total() = inner.sum()
}

fun main() {
    val list = SummarizedList(listOf(1, 2, 3))
    println(list.size)
    println(list.total())
}

Comptage des calls

Un décorateur peut suivre des métriques de manière transparente, ce qui est utile pour la surveillance sans toucher à l’implémentation réelle.

interface Service { fun call(): String }
class RealService : Service { override fun call() = "ok" }

class CountingService(private val inner: Service) : Service by inner {
    var calls = 0
        private set
    override fun call(): String {
        calls++
        return inner.call()
    }
}

fun main() {
    val s = CountingService(RealService())
    s.call(); s.call()
    println(s.calls)
}

Pourquoi la délégation l’emporte ici

Construire des décorateurs par héritage obligerait la classe de base à être open et lierait chaque décorateur à une classe concrète. La délégation dépend uniquement de l’interface ; les décorateurs restent donc faiblement couplés et composables.

Liste de vérification du modèle

Pour créer un décorateur fondé sur la délégation :

Prenez l’objet enveloppé comme private val
Déléguez l’interface avec by
Redéfinissez uniquement les membres que vous enrichissez
Appelez l’objet interne dans la redéfinition

Rassembler les éléments

Les décorateurs, les adaptateurs et les mandataires découlent naturellement de la délégation de classe. Associés à de petites interfaces, ils vous permettent de créer des systèmes flexibles et structurés en couches, faciles à vérifier et à étendre.

Vérification rapide

Évaluez votre compréhension des modèles pratiques de délégation.

Récapitulatif

Vous avez créé des décorateurs pratiques avec la délégation :

Enveloppes de journalisation, de mise en cache, de validation et de comptage
Empilement des décorateurs puisque chacun utilise la même interface
Redéfinition des seuls membres enrichis ; transmission de tous les autres

Cette partie termine le cours sur la délégation de classe.

Questions Fréquemment Posées

La leçon « Modèles pratiques » est-elle gratuite ?

Oui — le texte complet de « Modèles pratiques » 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 « Modèles pratiques » ?

Décorateurs avec délégation 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 4 sur 4.

Combien de temps prend la leçon « Modèles pratiques » ?

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