Effacement des types et paramètres de types reified
Utilisez reified avec des fonctions inline pour accéder aux informations de type à l’exécution.
Effacement des types et paramètres de types reified est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 l’effacement des types ?
À l’exécution, la JVM efface les arguments de type générique. List<String> et List<Int> deviennent toutes deux simplement List. Cela limite les opérations d’exécution sur les types génériques.
fun main() {
val strings: List<String> = listOf("a", "b")
val ints: List<Int> = listOf(1, 2)
println(strings.javaClass == ints.javaClass) // true: both ArrayList
println(strings is List<*>) // OK with star
// println(strings is List<String>) // warning: unchecked cast
}Le problème : impossible de vérifier les types effacés
Vous ne pouvez pas utiliser is avec un argument de type générique précis, car les informations de type ont disparu à l’exécution.
fun checkType(obj: Any) {
// This works:
if (obj is List<*>) println("It's a list of something")
// This doesn't compile cleanly:
// if (obj is List<String>) println("It's a list of strings") // unchecked
}
fun main() {
checkType(listOf("hello"))
checkType(42)
}Récapitulatif des fonctions inline
inline copie le corps de la fonction au niveau de l’appel lors de la compilation. C’est ce qui permet d’utiliser reified : l’argument de type est lui aussi remplacé au niveau de l’appel.
inline fun <T> myRun(block: () -> T): T = block()
fun main() {
val result = myRun { 42 }
println(result) // 42
// The compiler inlines the lambda body — no object allocation
}reified : accéder à T à l’exécution
La combinaison de inline et de reified conserve l’argument de type au niveau de l’appel, ce qui permet d’utiliser is, as et ::class sur T.
inline fun <reified T> isInstance(value: Any): Boolean = value is T
fun main() {
println(isInstance<String>("hello")) // true
println(isInstance<Int>("hello")) // false
println(isInstance<List<*>>(listOf())) // true
}Obtenir le KClass de T
Avec reified T, vous pouvez obtenir T::class à l’exécution — ce qui est normalement impossible dans les fonctions génériques.
inline fun <reified T> classNameOf(): String = T::class.simpleName ?: "Unknown"
fun main() {
println(classNameOf<String>()) // String
println(classNameOf<Int>()) // Int
println(classNameOf<List<*>>()) // List
}Conversion sûre avec reified
Utilisez reified pour écrire un utilitaire de conversion de type sûr qui retourne null au lieu de lever une exception.
inline fun <reified T> Any?.safeCast(): T? = this as? T
fun main() {
val obj: Any = "Hello"
val s: String? = obj.safeCast<String>()
val i: Int? = obj.safeCast<Int>()
println(s) // Hello
println(i) // null
}Analyse JSON avec reified
Des bibliothèques comme Gson ou kotlinx.serialization utilisent reified pour déduire le type cible au niveau de l’appel, sans transmettre explicitement des objets Class.
import com.google.gson.Gson
// Simulated without real Gson:
inline fun <reified T> parseJson(json: String): T {
return Gson().fromJson(json, T::class.java)
}
// Usage:
// val user: User = parseJson<User>("""{"name":"Alice"}""")reified avec filterIsInstance
La bibliothèque standard utilise filterIsInstance<T>() et reified pour filtrer une liste selon un type précis sans effectuer de conversion manuelle.
fun main() {
val mixed: List<Any> = listOf(1, "hello", 2.5, "world", true)
val strings = mixed.filterIsInstance<String>()
val ints = mixed.filterIsInstance<Int>()
println(strings) // [hello, world]
println(ints) // [1]
}Impossible d’utiliser reified dans des fonctions non-inline
reified ne fonctionne qu’avec les fonctions inline. Toute tentative de l’utiliser sans inline provoque une erreur de compilation.
// Error:
// fun <reified T> broken(): String = T::class.simpleName ?: "?"
// Must be inline:
inline fun <reified T> correct(): String = T::class.simpleName ?: "?"
fun main() {
println(correct<Double>()) // Double
}reified et réflexion
Combinez reified avec la réflexion pour inspecter dynamiquement les propriétés ou les annotations d’un type, sans paramètres Class superflus.
inline fun <reified T : Any> properties(): List<String> =
T::class.members.map { it.name }
data class Point(val x: Int, val y: Int)
fun main() {
println(properties<Point>()) // [x, y, component1, component2, copy, equals, hashCode, toString]
}Pratique : localisateur de services sûr du point de vue des types
Utilisez reified pour créer un localisateur de services qui associe des KClass à des instances, afin d’obtenir une DI légère sans processeurs d’annotations.
val registry = mutableMapOf<kotlin.reflect.KClass<*>, Any>()
inline fun <reified T : Any> register(instance: T) { registry[T::class] = instance }
@Suppress("UNCHECKED_CAST")
inline fun <reified T : Any> resolve(): T = registry[T::class] as T
class Logger { fun log(msg: String) = println("[LOG] $msg") }
fun main() {
register(Logger())
resolve<Logger>().log("Service located!")
}Limites de reified
Les paramètres de type reified ne peuvent pas être utilisés dans des contextes non-inline, ne peuvent pas stocker le type pour une utilisation ultérieure et ne peuvent pas être transmis à des fonctions non-inline qui ont besoin du type à l’exécution.
inline fun <reified T> foo() {
val clazz = T::class // OK here
// bar(clazz) // must pass clazz explicitly to non-inline funs
println(clazz.simpleName)
}
fun bar(clazz: kotlin.reflect.KClass<*>) = println(clazz.simpleName)
fun main() { foo<String>() }Vérification rapide
Quelle est la condition requise pour qu’un paramètre de type soit reified ?
Récapitulatif
L’effacement des types supprime les informations de type générique à l’exécution. reified sur les fonctions inline conserve l’argument de type au niveau de l’appel, ce qui permet d’utiliser is, as, ::class et la réflexion sur T — sans transmettre manuellement des objets Class.
Apprends Kotlin avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 51
- Leçons
- 203
Questions Fréquemment Posées
La leçon « Effacement des types et paramètres de types reified » est-elle gratuite ?
Oui — le texte complet de « Effacement des types et paramètres de types reified » 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 « Effacement des types et paramètres de types reified » ?
Utilisez reified avec des fonctions inline pour accéder aux informations de type à 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 4 sur 4.
Combien de temps prend la leçon « Effacement des types et paramètres de types reified » ?
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
- Fonctions génériques et contraintes de types avec where
- Variance au site de déclaration : in et out
- Projection étoilée et utilisation de *
- Effacement des types et paramètres de types reified