Kotlin Academy · Leçon

Classes imbriquées

Des classes à l’intérieur d’autres classes

Classes imbriquées est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Des classes à l’intérieur des classes

Kotlin vous permet de déclarer une classe à l’intérieur d’une autre classe. Par défaut, cette classe est imbriquée et ne contient pas de référence vers l’instance externe.

class Outer {
    class Nested {
        fun hello() = "Hi from Nested"
    }
}

fun main() {
    println(Outer.Nested().hello())
}

Créer une instance imbriquée

Comme une classe imbriquée est indépendante, vous la créez avec le nom de la classe externe, sans instance externe : Outer.Nested().

class Computer {
    class Cpu {
        val cores = 8
    }
}

fun main() {
    val cpu = Computer.Cpu()
    println(cpu.cores)
}

Aucun accès aux membres externes

Une classe imbriquée ne peut pas accéder aux membres d’instance de la classe externe, car elle ne possède aucune référence externe. Elle se comporte comme une classe de niveau supérieur placée dans un espace de noms.

class Bank {
    val name = "ACME"
    class Branch {
        fun describe() = "A branch"
    }
}

fun main() {
    println(Bank.Branch().describe())
}

Pourquoi imbriquer des classes ?

L’imbrication exprime un regroupement logique : le type interne appartient conceptuellement au type externe, ce qui améliore l’organisation et la gestion des espaces de noms.

class Http {
    class Request(val url: String)
}

fun main() {
    val r = Http.Request("/home")
    println(r.url)
}

Classe imbriquée avec des propriétés

Les classes imbriquées sont des classes ordinaires : elles peuvent avoir des constructeurs, des propriétés et des méthodes.

class Garage {
    class Car(val model: String) {
        fun honk() = "$model: beep"
    }
}

fun main() {
    println(Garage.Car("Tesla").honk())
}

Accéder aux membres de type compagnon ou assimilés aux membres statiques

Les classes imbriquées peuvent être référencées depuis n’importe où à l’aide du nom de la classe englobante, comme une classe imbriquée statique en Java.

class Config {
    class Defaults {
        val timeout = 30
    }
}

fun main() {
    println(Config.Defaults().timeout)
}

Plusieurs classes imbriquées

Une classe englobante peut contenir plusieurs classes imbriquées afin de regrouper des types associés.

class Shapes {
    class Circle(val r: Int)
    class Square(val side: Int)
}

fun main() {
    println(Shapes.Circle(5).r)
    println(Shapes.Square(4).side)
}

Imbrication de classes

Vous pouvez imbriquer des classes sur plusieurs niveaux, même si une imbrication trop profonde peut nuire à la lisibilité.

class A {
    class B {
        class C {
            val value = 42
        }
    }
}

fun main() {
    println(A.B.C().value)
}

Classe imbriquée ou de niveau supérieur

Fonctionnellement, une classe imbriquée ressemble à une classe de niveau supérieur ; seule son nom qualifié diffère. Choisissez l’imbrication lorsque la relation améliore la clarté.

class Order {
    class Item(val price: Int)
}

fun main() {
    val total = Order.Item(10).price + Order.Item(5).price
    println(total)
}

Un regroupement pratique

Regrouper le type de résultat d’un générateur sous son propriétaire rend le code naturel à lire.

class Parser {
    class Result(val ok: Boolean, val message: String)

    fun parse(text: String) = Result(text.isNotEmpty(), "parsed")
}

fun main() {
    val res = Parser().parse("data")
    println("${res.ok} ${res.message}")
}

La règle essentielle à retenir

Le mot-clé qui permet à une classe de conserver une référence vers la classe englobante est inner. Sans lui, une classe imbriquée se comporte comme une classe statique et reste isolée.

class Box {
    class Lid
}

fun main() {
    println(Box.Lid() != null)
}

Vérification rapide

Vérifiez votre compréhension des classes imbriquées.

Récapitulatif

Vous avez découvert les classes imbriquées :

Déclarées à l’intérieur d’une autre classe, elles sont par défaut des class (imbriquées).
Elles ne possèdent aucune référence vers l’instance englobante et ne peuvent pas accéder à ses membres.
Elles sont créées via le nom de la classe englobante : Outer.Nested().
Elles sont idéales pour regrouper logiquement des éléments et créer un espace de noms.

class Outer {
    class Nested { val x = 1 }
}

fun main() {
    println(Outer.Nested().x)
}

Questions Fréquemment Posées

La leçon « Classes imbriquées » est-elle gratuite ?

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

Des classes à l’intérieur d’autres classes 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 1 sur 4.

Combien de temps prend la leçon « Classes imbriquées » ?

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