0Pricing
Kotlin Academy · Aula

Reflexão no Kotlin: KClass, KFunction, KProperty

Navegue pelos metadados de classes usando KClass e inspecione membros por reflexão.

Reflexão no Kotlin: KClass, KFunction, KProperty é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 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 é reflexão?

A reflexão permite que o código inspecione e invoque a própria estrutura em tempo de execução: classes, funções, propriedades, anotações e construtores. O Kotlin encapsula a API de reflexão da JVM com seus próprios tipos mais completos no pacote kotlin.reflect.

Obtendo uma KClass

Use ::class em um tipo ou uma instância para obter uma referência KClass:

val klass: KClass<String> = String::class
val instance: KClass<out Any> = "hello"::class
println(klass.simpleName)  // "String"

Propriedades de KClass

KClass expõe metadados sobre a classe:

val klass = String::class
println(klass.simpleName)        // "String"
println(klass.qualifiedName)     // "kotlin.String"
println(klass.isAbstract)        // false
println(klass.constructors.size) // number of constructors

KFunction: referências chamáveis

Use ::functionName para obter uma referência KFunction. Você pode inspecionar seus parâmetros e invocá-la:

fun greet(name: String) = "Hello, $name!"

val fn: KFunction<String> = ::greet
println(fn.name)           // "greet"
println(fn.call("Kotlin")) // "Hello, Kotlin!"

Inspecionando parâmetros

KFunction.parameters retorna uma lista de objetos KParameter com nome, tipo e opcionalidade:

fun add(a: Int, b: Int) = a + b

::add.parameters.forEach {
    println("${it.name}: ${it.type}")
}
// a: kotlin.Int
// b: kotlin.Int

KProperty: referências de propriedades

As referências de propriedades capturam uma propriedade como um objeto de primeira classe. KProperty0 é usado para propriedades sem receptor; KProperty1 é usado para propriedades de membro.

data class User(val name: String, val age: Int)

val prop: KProperty1<User, String> = User::name
val user = User("Alice", 30)
println(prop.get(user))  // "Alice"

Propriedades mutáveis com KMutableProperty

Para propriedades var, a referência é uma KMutableProperty1, que também possui uma função set:

class Box(var value: Int)

val prop: KMutableProperty1<Box, Int> = Box::value
val box = Box(10)
prop.set(box, 42)
println(box.value)  // 42

Listando todos os membros

KClass.members retorna todos os membros visíveis (funções + propriedades). KClass.declaredMemberProperties retorna apenas as propriedades declaradas nessa classe.

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

Point::class.declaredMemberProperties.forEach {
    println(it.name)  // "x", "y"
}

Criando instâncias por meio de KClass

Invoque KClass.createInstance() (é necessário um construtor sem argumentos) ou use KClass.constructors para ter controle total:

class Counter {
    var count = 0
}
val c = Counter::class.createInstance()
c.count = 5
println(c.count)  // 5

Dependência Kotlin Reflect

A reflexão do Kotlin exige o artefato kotlin-reflect (não incluído na biblioteca padrão). Adicione-o à sua compilação:

// build.gradle.kts
implementation("org.jetbrains.kotlin:kotlin-reflect")

Observação sobre desempenho

A reflexão é significativamente mais lenta que o código direto. Armazene em cache as referências KClass, KFunction e KProperty na inicialização. Evite invocá-las em laços de alta frequência. Para a maioria dos códigos de ferramentas e estruturas, esse custo é aceitável.

Verificação rápida

Qual tipo do Kotlin representa uma referência a uma propriedade de membro e permite ler seu valor a partir de uma instância?

Recapitulação: reflexão do Kotlin

Tipos principais:

  • KClass — metadados da classe, construtores e membros
  • KFunction — referências chamáveis, parâmetros e invocação
  • KProperty1 / KMutableProperty1 — referências de propriedades, leitura/escrita
  • Exige kotlin-reflect no caminho de classes
  • Armazene as referências em cache; evite usá-las em caminhos críticos

Perguntas Frequentes

A aula “Reflexão no Kotlin: KClass, KFunction, KProperty” é grátis?

Sim — o texto completo de “Reflexão no Kotlin: KClass, KFunction, KProperty” é 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 “Reflexão no Kotlin: KClass, KFunction, KProperty”?

Navegue pelos metadados de classes usando KClass e inspecione membros por reflexã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 1 de 4.

Quanto tempo leva a aula “Reflexão no Kotlin: KClass, KFunction, KProperty”?

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

  1. Reflexão no Kotlin: KClass, KFunction, KProperty
  2. Criando e direcionando anotações personalizadas
  3. Lendo anotações em tempo de execução
  4. Validação e mapeamento baseados em reflexão
← Voltar para Kotlin Academy