0Pricing
Kotlin Academy · Leçon

Objets anonymes et expressions object

Utilisez des expressions object pour créer des implémentations ponctuelles d’interfaces.

Objets anonymes et expressions object 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.

Expressions d’objet

Une expression d’objet crée une instance anonyme et ponctuelle d’une classe ou d’une interface — l’équivalent Kotlin des classes internes anonymes de Java, mais en plus puissant.

Implémenter anonymement une interface

Utilisez object : Interface { ... } pour créer une implémentation intégrée.

interface ClickListener {
    fun onClick(): String
}
fun main() {
    val listener = object : ClickListener {
        override fun onClick() = "clicked!"
    }
    println(listener.onClick())
}

Classe anonyme avec état

Les objets anonymes peuvent contenir un état et plusieurs méthodes.

fun main() {
    val counter = object {
        var count = 0
        fun inc() { count++ }
        fun show() = println("count = $count")
    }
    counter.inc(); counter.inc(); counter.inc()
    counter.show()
}

Type d’objet anonyme

Le type d’un objet anonyme est inféré. Lorsqu’il est déclaré au niveau d’une fonction, vous conservez l’accès à ses membres personnalisés.

fun main() {
    val pair = object {
        val left = "L"
        val right = "R"
    }
    println("${pair.left} and ${pair.right}")
}

Exposition du type anonyme

Si un objet anonyme est renvoyé par une fonction dont le type est inféré, les appelants ne voient que le supertype — les ajouts propres à l’objet anonyme sont inaccessibles depuis l’extérieur.

fun makeListener() = object {
    fun greet() = "hello"
}
fun main() {
    val l = makeListener()
    println(l.greet()) // OK — same compilation unit
}

Interfaces multiples

Un objet anonyme peut implémenter plusieurs interfaces dans une seule expression.

interface Closeable { fun close() }
interface Flushable { fun flush() }
fun main() {
    val resource = object : Closeable, Flushable {
        override fun close() = println("closed")
        override fun flush() = println("flushed")
    }
    resource.flush()
    resource.close()
}

Étendre une classe

Les objets anonymes peuvent étendre une classe ouverte tout en redéfinissant ses membres.

open class Animal(val name: String) {
    open fun speak() = "$name makes a sound"
}
fun main() {
    val pet = object : Animal("Rex") {
        override fun speak() = "$name barks!"
    }
    println(pet.speak())
}

Capturer les variables englobantes

Les objets anonymes capturent les variables de la portée englobante, ce qui permet de les lire et de les modifier — contrairement à l’exigence Java de les déclarer final.

fun main() {
    var log = mutableListOf<String>()
    val recorder = object {
        fun record(s: String) { log.add(s) }
    }
    recorder.record("event 1")
    recorder.record("event 2")
    println(log)
}

Quand utiliser des objets anonymes

Utilisez des objets anonymes pour les implémentations ponctuelles qui ne justifient pas leur propre classe — généralement des rappels, des écouteurs ou des comparateurs.

fun main() {
    val nums = listOf(3, 1, 4, 1, 5, 9, 2, 6)
    val sorted = nums.sortedWith(object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a // descending
    })
    println(sorted)
}

Préférer les lambdas lorsque c’est possible

Si l’interface possède une seule méthode abstraite (SAM), une lambda est plus claire qu’une expression d’objet.

fun main() {
    val nums = listOf(3, 1, 4, 1, 5, 9)
    // Old way:
    val sorted1 = nums.sortedWith(object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    })
    // New way — SAM conversion:
    val sorted2 = nums.sortedWith(Comparator { a, b -> b - a })
    println("$sorted1 / $sorted2")
}

Objet anonyme ou objet déclaré

Utilisez object Name pour un singleton nommé. Utilisez object : Type dans une expression pour une instance anonyme ponctuelle.

// Named singleton (one instance, accessed globally)
object GlobalLogger { fun log(m: String) = println("[L] $m") }
// Anonymous (created at expression evaluation)
fun main() {
    val local = object { fun hi() = "hi" }
    GlobalLogger.log("hello")
    println(local.hi())
}

Vérification rapide

Quelle syntaxe crée une instance anonyme implémentant une interface intégrée ?

Récapitulatif

Les expressions d’objet créent des instances anonymes ponctuelles directement dans le code. Elles peuvent implémenter des interfaces, étendre des classes, contenir un état et capturer les variables englobantes. Préférez les lambdas pour les interfaces à méthode unique ; utilisez les expressions d’objet lorsque vous avez besoin de plusieurs méthodes ou d’un état.

Questions Fréquemment Posées

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

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

Utilisez des expressions object pour créer des implémentations ponctuelles d’interfaces. 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 et expressions object » ?

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

  1. Déclaration object : singletons Kotlin
  2. companion object : membres semblables aux membres statiques
  3. Objets anonymes et expressions object
  4. Méthodes fabrique avec companion object
← Retour à Kotlin Academy