Apagamento de tipos e parâmetros de tipo reified
Use reified com funções inline para acessar informações de tipo em tempo de execução.
Apagamento de tipos e parâmetros de tipo reified é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.
O que é o apagamento de tipos?
Em tempo de execução, a JVM apaga os argumentos de tipo genéricos. List<String> e List<Int> são apenas List. Isso limita as operações de tipo em tempo de execução sobre tipos genéricos.
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
}O problema: não é possível verificar tipos apagados
Não é possível usar is com um argumento de tipo genérico específico porque as informações do tipo desaparecem em tempo de execução.
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)
}Revisão das funções inline
inline copia o corpo da função para o ponto de chamada em tempo de compilação. É isso que habilita reified — o argumento de tipo também é substituído no ponto de chamada.
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: acessando T em tempo de execução
A combinação de inline com reified preserva o argumento de tipo no ponto de chamada, habilitando is, as e ::class em 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
}Obtendo KClass de T
Com reified T, você pode obter T::class em tempo de execução — algo normalmente impossível em funções genéricas.
inline fun <reified T> classNameOf(): String = T::class.simpleName ?: "Unknown"
fun main() {
println(classNameOf<String>()) // String
println(classNameOf<Int>()) // Int
println(classNameOf<List<*>>()) // List
}Conversão segura com reified
Use reified para escrever um utilitário de conversão seguro quanto aos tipos que retorna nulo em vez de lançar uma exceção.
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
}Análise de JSON com reified
Bibliotecas como Gson ou kotlinx.serialization usam reified para inferir o tipo de destino no ponto de chamada sem receber objetos Class explicitamente.
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 com filterIsInstance
O filterIsInstance<T>() da biblioteca padrão usa reified para filtrar uma lista para um tipo específico sem conversão manual.
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]
}Não é possível usar reified em funções que não são inline
reified só funciona com funções inline. Tentar usá-lo sem inline gera um erro de compilação.
// 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 e reflexão
Combine reified com reflexão para inspecionar propriedades ou anotações de um tipo dinamicamente, sem parâmetros Class repetitivos.
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]
}Prática: localizador de serviços seguro quanto aos tipos
Use reified para criar um localizador de serviços que associa KClass a instâncias, oferecendo DI leve sem processadores de anotações.
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!")
}Limitações de reified
Parâmetros de tipo reified não podem ser usados em contextos que não são inline, não podem armazenar o tipo para uso posterior e não podem ser passados a funções que não são inline e precisam do tipo em tempo de execução.
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>() }Verificação rápida
O que é necessário para que um parâmetro de tipo seja reified?
Revisão
O apagamento de tipos remove as informações de tipos genéricos em tempo de execução. reified em funções inline preserva o argumento de tipo no ponto de chamada, habilitando is, as, ::class e reflexão sobre T — sem passar objetos Class manualmente.
Aprenda Kotlin com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Apagamento de tipos e parâmetros de tipo reified” é grátis?
Sim — o texto completo de “Apagamento de tipos e parâmetros de tipo reified” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.
O que vou aprender em “Apagamento de tipos e parâmetros de tipo reified”?
Use reified com funções inline para acessar informações de tipo em tempo de execução. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kotlin Academy?
Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Apagamento de tipos e parâmetros de tipo reified”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kotlin Academy?
Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Funções genéricas e restrições de tipos com where
- Variância no local da declaração: in e out
- Projeção estrela e quando usar *
- Apagamento de tipos e parâmetros de tipo reified