Kotlin Academy · Leçon

Classes internes

Accéder à la portée externe

Classes internes 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.

Le mot-clé inner

Marquer une classe imbriquée avec inner lui fournit une référence vers l’instance englobante, ce qui lui permet d’accéder aux membres de la classe englobante.

class Outer {
    val msg = "Hello"
    inner class Inner {
        fun show() = msg
    }
}

fun main() {
    println(Outer().Inner().show())
}

Créer une instance inner

Comme une classe inner a besoin d’une instance englobante, vous la créez à partir de celle-ci : Outer().Inner().

class Engine {
    val power = 100
    inner class Turbo {
        fun boosted() = power * 2
    }
}

fun main() {
    println(Engine().Turbo().boosted())
}

Accéder aux propriétés englobantes

Une classe inner lit et utilise directement les propriétés de la classe englobante, comme si elles lui appartenaient.

class Counter {
    var count = 0
    inner class Stepper {
        fun step() { count++ }
    }
}

fun main() {
    val c = Counter()
    c.Stepper().step()
    println(c.count)
}

Appeler les méthodes englobantes

Les classes inner peuvent également appeler des méthodes sur l’instance englobante.

class Printer {
    fun line(s: String) = println(s)
    inner class Job {
        fun run() = line("printing")
    }
}

fun main() {
    Printer().Job().run()
}

La syntaxe this@Outer

Pour faire explicitement référence à l’instance englobante, par exemple lorsque des noms sont en conflit, utilisez this@Outer.

class Outer {
    val value = 10
    inner class Inner {
        val value = 20
        fun outerValue() = this@Outer.value
    }
}

fun main() {
    println(Outer().Inner().outerValue())
}

Pourquoi utiliser inner ?

Utilisez inner lorsque le type imbriqué doit réellement collaborer avec une instance englobante précise et partager son état.

class Wallet {
    var balance = 50
    inner class Transaction(val amount: Int) {
        fun apply() { balance += amount }
    }
}

fun main() {
    val w = Wallet()
    w.Transaction(25).apply()
    println(w.balance)
}

Chaque instance inner est liée à une seule instance englobante

Une instance inner est liée exactement à l’instance englobante qui l’a créée ; les modifications sont donc propagées à cet objet.

class Box(var size: Int) {
    inner class Resizer {
        fun grow() { size += 1 }
    }
}

fun main() {
    val b = Box(3)
    b.Resizer().grow()
    println(b.size)
}

Inner ou imbriquée

Sans inner, une classe imbriquée est isolée. Avec inner, elle capture l’instance englobante. Le mot-clé fait toute la différence.

class Outer {
    val tag = "X"
    inner class A { fun get() = tag }
}

fun main() {
    println(Outer().A().get())
}

Remarque sur la mémoire

Comme une instance inner maintient en vie l’instance englobante, soyez prudent avec les objets inner qui vivent longtemps afin d’éviter de conserver involontairement l’objet englobant.

class Service {
    val id = 1
    inner class Worker { fun who() = id }
}

fun main() {
    println(Service().Worker().who())
}

Un itérateur réaliste

Une classe inner convient parfaitement à un itérateur qui parcourt l’état de la collection dans laquelle elle est englobée.

class Stack {
    private val items = mutableListOf(1, 2, 3)
    inner class Reader {
        fun all() = items.joinToString()
    }
}

fun main() {
    println(Stack().Reader().all())
}

Combiner les concepts

Les classes inner peuvent utiliser l’état de la classe englobante et lever les ambiguïtés avec this@Outer.

class Outer {
    val n = 5
    inner class Inner {
        fun doubled() = this@Outer.n * 2
    }
}

fun main() {
    println(Outer().Inner().doubled())
}

Vérification rapide

Vérifiez votre compréhension des classes inner.

Récapitulatif

Vous avez découvert les classes inner :

inner donne accès à l’instance englobante et à ses membres.
Créez-les via une instance englobante : Outer().Inner().
Utilisez this@Outer pour faire référence à l’instance englobante.
Les instances inner maintiennent leur instance englobante en vie.

class Outer {
    val v = 1
    inner class Inner { fun get() = v }
}

fun main() {
    println(Outer().Inner().get())
}

Questions Fréquemment Posées

La leçon « Classes internes » est-elle gratuite ?

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

Accéder à la portée externe 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 « Classes internes » ?

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