Kotlin Academy · Leçon

Bases de la réflexion

Inspecter les types à l’exécution

Bases de la réflexion 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.

Qu'est-ce que la réflexion ?

La réflexion est la capacité d'un programme à inspecter et à manipuler sa propre structure à l'exécution : classes, propriétés, fonctions et annotations.

La réflexion de Kotlin se trouve dans le paquetage kotlin.reflect et s'articule autour de KClass.

Obtenir une KClass

Utilisez la syntaxe ::class sur un type ou une instance pour obtenir son objet KClass.

class Robot

fun main() {
    val fromType = Robot::class
    val fromInstance = Robot()::class
    println(fromType.simpleName)
    println(fromInstance.simpleName)
}

Noms d'une classe

Une KClass expose simpleName et qualifiedName. Le nom qualifié inclut le chemin du paquetage.

class Engine

fun main() {
    val k = Engine::class
    println(k.simpleName)
    println(k.qualifiedName)
}

Inspecter les propriétés

memberProperties répertorie les propriétés d'une classe. Chacune est une KProperty dont vous pouvez demander le name.

import kotlin.reflect.full.memberProperties

class Point(val x: Int, val y: Int)

fun main() {
    for (p in Point::class.memberProperties) {
        println(p.name)
    }
}

Lire les valeurs des propriétés

Une KProperty1 peut être invoquée avec une instance pour lire sa valeur via get(instance).

import kotlin.reflect.full.memberProperties

class Point(val x: Int, val y: Int)

fun main() {
    val p = Point(3, 4)
    for (prop in Point::class.memberProperties) {
        println(prop.name + " = " + prop.get(p))
    }
}

Inspecter les fonctions

memberFunctions renvoie les fonctions appelables d'une classe sous forme d'objets KFunction. Vous pouvez lire le name de chaque fonction.

import kotlin.reflect.full.memberFunctions

class Calculator {
    fun add(a: Int, b: Int) = a + b
    fun negate(a: Int) = -a
}

fun main() {
    Calculator::class.memberFunctions
        .filter { it.name in listOf("add", "negate") }
        .forEach { println(it.name) }
}

Références de fonctions

La syntaxe ::name produit une référence appelable de type KFunction. Vous pouvez l'invoquer ultérieurement avec invoke ou la transmettre.

fun double(n: Int) = n * 2

fun main() {
    val ref = ::double
    println(ref.name)
    println(ref.invoke(21))
}

Créer des instances

createInstance() crée un objet par réflexion lorsque la classe possède un constructeur sans argument.

import kotlin.reflect.full.createInstance

class Widget {
    override fun toString() = "Widget"
}

fun main() {
    val w = Widget::class.createInstance()
    println(w)
}

Inspecter les constructeurs

constructors répertorie les constructeurs de la classe. Vous pouvez examiner leurs parameters pour savoir quels arguments ils attendent.

class Person(val name: String, val age: Int)

fun main() {
    val ctor = Person::class.constructors.first()
    ctor.parameters.forEach { println(it.name) }
}

Coûts et réserves

La réflexion est puissante, mais :

Elle est plus lente que les appels directs
Elle contourne la sécurité assurée lors de la compilation
Elle nécessite la bibliothèque kotlin-reflect sur la JVM

Utilisez-la pour les infrastructures et les outils, pas dans les boucles très fréquentes.

La boîte à outils de la réflexion

Types essentiels à retenir :

KClass — une classe
KProperty — une propriété
KFunction — une fonction
KParameter — un paramètre

Ensemble, ils vous permettent de lire dynamiquement une structure.

Vérification rapide

Vérifiez votre compréhension des bases de la réflexion.

Récapitulatif

Vous avez appris les bases de la réflexion :

Obtenir une KClass via ::class
Répertorier memberProperties et memberFunctions
Lire les valeurs des propriétés et invoquer des références de fonctions
Créer des objets avec createInstance()

Ensuite : lire dynamiquement les annotations.

Questions Fréquemment Posées

La leçon « Bases de la réflexion » est-elle gratuite ?

Oui — le texte complet de « Bases de la réflexion » 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 « Bases de la réflexion » ?

Inspecter les types à l’exécution 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 « Bases de la réflexion » ?

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