Classes imbriquées et classes internes en Kotlin

Dans cet article, vous apprendrez à utiliser les classes imbriquées et les classes internes à l'aide d'exemples.

Classes imbriquées en Kotlin

Comme en Java, Kotlin vous permet de définir une classe dans une autre classe appelée classe imbriquée

class Outer {
　　　　...　..　...
　　　　class Nested {
　　　　　　　　...　..　...
　　　　}
}

Comme en Java, Kotlin vous permet de définir une classe dans une autre classe appelée classe imbriquée, appelée Outer ici, vous pouvez utiliser le symbole . pour accéder à la classe imbriquée et à ses membres.

Exemple : Exemple d'utilisation des classes imbriquées en Kotlin

class Outer {
　　　　val a = "à l'extérieur de la classe imbriquée."
　　　　class Nested {
　　　　　　　　val b = "En dehors de la classe imbriquée."
　　　　　　　　fun callMe() = "Appel de la fonction à partir de l'intérieur de la classe imbriquée."
　　　　}
}
fun main(args: Array<String>) {
　　　　//Accès aux membres de la classe imbriquée
　　　　println(Outer.Nested().b)
　　　　//Création d'un objet de classe imbriquée
　　　　val nested = Outer.Nested()
　　　　println(nested.callMe())
}

Lorsque ce programme est exécuté, la sortie est :

À l'intérieur de la classe imbriquée.
Appel de la fonction à partir de l'intérieur de la classe imbriquée.

Pour les utilisateurs de Java

Les classes imbriquées en Kotlin sont similaires aux classes statiques imbriquées en Java.

En Java, lorsque vous déclarez une classe dans une autre classe, par défaut, elle deviendra une classe interne. Mais en Kotlin, vous devez utiliser le modificateur inner pour créer une classe interne, ce que nous discuterons ci-dessous.

Classes internes en Kotlin

Les classes imbriquées en Kotlin n'ont pas le droit d'accéder à l'instance de la classe externe. Par exemple,

class Outer {
　　　　val foo = "En dehors de la classe imbriquée."
　　　　class Nested {
　　　　　　　　//Erreur ! Impossible d'accéder aux membres de la classe externe.
　　　　　　　　fun callMe() = foo
　　　　}
}
fun main(args: Array<String>) {
　　　　val outer = Outer()
　　　　println(outer.Nested().callMe())
}

Le code ci-dessus ne peut pas être compilé, car nous essayons d'accéder à l'attribut foo de la classe externe à partir de l'intérieur de la classe imbriquée.

Pour résoudre ce problème, vous devez utiliser le marqueur inner pour créer une classe interne. Une classe interne porte une référence à la classe externe et peut accéder aux membres de la classe externe.

Exemple : Utilisation des classes internes dans Kotlin

class Outer {
　　　　val a = "à l'extérieur de la classe imbriquée."
　　　　inner class Inner {
　　　　　　　　fun callMe() = a
　　　　}
}
fun main(args: Array<String>) {
　　　　val outer = Outer()
　　　　println("Utilisation de l'objet externe: ${outer.Inner().callMe()}")
　　　　val inner = Outer().Inner()
　　　　println("Utilisation de l'objet interne: ${inner.callMe()}")
}

Lorsque ce programme est exécuté, la sortie est :

Utilisation de l'objet externe : à l'extérieur de la classe imbriquée.
Utilisation de l'objet interne : à l'extérieur de la classe imbriquée.