Kotlin Academy · Leçon

Objets anonymes

Implémentations intégrées

Objets anonymes 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.

Implémentations intégrées

Un objet anonyme crée une instance d’une classe ou d’une interface sans nommer une nouvelle classe. Utilisez l’expression object.

interface Greeter { fun greet(): String }

fun main() {
    val g = object : Greeter {
        override fun greet() = "Hi"
    }
    println(g.greet())
}

Implémenter une interface

Une expression objet peut implémenter une ou plusieurs interfaces directement à l’endroit où cela est nécessaire.

interface Clickable { fun click() }

fun main() {
    val button = object : Clickable {
        override fun click() = println("Clicked")
    }
    button.click()
}

Redéfinir les membres d’une classe

Vous pouvez dériver anonymement une classe ouverte et redéfinir ses membres.

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

fun main() {
    val cat = object : Animal() {
        override fun sound() = "Meow"
    }
    println(cat.sound())
}

Conserver un état supplémentaire

Un objet anonyme peut déclarer ses propres propriétés en plus des membres qu’il redéfinit.

fun main() {
    val point = object {
        val x = 3
        val y = 4
    }
    println("${point.x}, ${point.y}")
}

Objet sans supertype

Si vous omettez le supertype, l’objet n’est qu’un regroupement ponctuel de membres, utile pour un regroupement local rapide.

fun main() {
    val config = object {
        val retries = 3
        val timeout = 30
    }
    println(config.retries)
}

Capturer des variables locales

Les objets anonymes peuvent capturer des variables de la portée englobante, contrairement aux classes imbriquées statiques.

fun makeCounter(start: Int): () -> Int {
    var count = start
    val obj = object {
        fun next() = count++
    }
    return { obj.next() }
}

fun main() {
    val c = makeCounter(10)
    println(c())
    println(c())
}

Comme écouteur

Un usage courant consiste à transmettre une implémentation intégrée comme fonction de rappel ou comme écouteur.

interface OnDone { fun done(result: Int) }

fun compute(cb: OnDone) {
    cb.done(42)
}

fun main() {
    compute(object : OnDone {
        override fun done(result: Int) = println("Got $result")
    })
}

Type d’un objet anonyme

Lorsqu’il est renvoyé par une fonction, le type inféré est le supertype déclaré, ou le type universel si aucun n’est indiqué. Les membres supplémentaires ne sont visibles que localement.

interface Named { val name: String }

fun make(): Named = object : Named {
    override val name = "X"
}

fun main() {
    println(make().name)
}

Objets anonymes ou lambdas

Pour les interfaces à méthode unique, une lambda est plus concise, mais les objets anonymes sont nécessaires lorsque vous devez redéfinir plusieurs membres ou conserver un état.

interface Handler {
    fun onStart()
    fun onStop()
}

fun main() {
    val h = object : Handler {
        override fun onStart() = println("start")
        override fun onStop() = println("stop")
    }
    h.onStart()
    h.onStop()
}

Expression objet ou déclaration objet

Une expression objet crée une nouvelle instance à chaque utilisation. Une déclaration objet (object Name {}) est un singleton nommé. Elles se ressemblent, mais leur durée de vie diffère.

object Singleton { val id = 1 }

fun main() {
    val fresh = object { val id = 2 }
    println(Singleton.id)
    println(fresh.id)
}

Un comparateur compact

Les objets anonymes sont pratiques pour des comparateurs ou des stratégies utilisés une seule fois.

fun main() {
    val cmp = object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    }
    val list = listOf(1, 3, 2).sortedWith(cmp)
    println(list)
}

Vérification rapide

Vérifiez votre compréhension des objets anonymes.

Récapitulatif

Vous avez découvert les objets anonymes :

L’expression object : Type {} crée une instance sans nom.
Ils peuvent implémenter des interfaces, dériver de classes ouvertes et conserver un état.
Ils capturent les variables locales de la portée englobante.
Utilisez-les pour les fonctions de rappel comportant plusieurs méthodes ; préférez les lambdas pour les méthodes uniques.

interface Run { fun go() }

fun main() {
    val r = object : Run { override fun go() = println("go") }
    r.go()
}

Questions Fréquemment Posées

La leçon « Objets anonymes » est-elle gratuite ?

Oui — le texte complet de « Objets anonymes » 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 « Objets anonymes » ?

Implémentations intégrées 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 « Objets anonymes » ?

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