Kotlin Academy · Aula

Noções Básicas de Reflexão

Inspecione tipos durante a execução

Noções Básicas de Reflexão é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 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

Reflexão é a capacidade de um programa inspecionar e manipular sua própria estrutura em tempo de execução: classes, propriedades, funções e anotações.

A reflexão de Kotlin está no pacote kotlin.reflect e se concentra em KClass.

Obtendo uma KClass

Use a sintaxe ::class em um tipo ou uma instância para obter seu objeto KClass.

class Robot

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

Nomes de uma classe

Uma KClass expõe simpleName e qualifiedName. O nome qualificado inclui o caminho do pacote.

class Engine

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

Inspecionando propriedades

memberProperties lista as propriedades de uma classe. Cada uma é uma KProperty, da qual você pode obter o 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)
    }
}

Lendo valores de propriedades

Uma KProperty1 pode ser chamada com uma instância para ler seu valor por meio de 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))
    }
}

Inspecionando funções

memberFunctions retorna as funções chamáveis de uma classe como objetos KFunction. Você pode ler o name de cada função.

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) }
}

Referências de funções

A sintaxe ::name produz uma referência chamável do tipo KFunction. Você pode invocá-la mais tarde com invoke ou transmiti-la para outro lugar.

fun double(n: Int) = n * 2

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

Criando instâncias

createInstance() cria um objeto por reflexão quando a classe tem um construtor sem argumentos.

import kotlin.reflect.full.createInstance

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

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

Inspecionando construtores

constructors lista os construtores da classe. Você pode examinar seus parameters para descobrir quais argumentos eles esperam.

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

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

Custos e ressalvas

A reflexão é poderosa, mas:

É mais lenta que chamadas diretas
Ignora a segurança em tempo de compilação
Exige a biblioteca kotlin-reflect na JVM

Use-a em estruturas e ferramentas, não em laços executados repetidamente.

A caixa de ferramentas da reflexão

Principais tipos para lembrar:

KClass — uma classe
KProperty — uma propriedade
KFunction — uma função
KParameter — um parâmetro

Juntos, eles permitem ler a estrutura dinamicamente.

Verificação rápida

Teste sua compreensão dos fundamentos da reflexão.

Recapitulação

Você aprendeu os fundamentos da reflexão:

Obter uma KClass por meio de ::class
Listar memberProperties e memberFunctions
Ler valores de propriedades e invocar referências de funções
Criar objetos com createInstance()

Em seguida: ler anotações dinamicamente.

Perguntas Frequentes

A aula “Noções Básicas de Reflexão” é grátis?

Sim — o texto completo de “Noções Básicas de Reflexão” é 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 “Noções Básicas de Reflexão”?

Inspecione tipos durante a 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 3 de 4.

Quanto tempo leva a aula “Noções Básicas de Reflexão”?

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

← Voltar para Kotlin Academy