Kotlin Academy · Lección

Conceptos básicos de reflection

Inspeccione tipos en tiempo de ejecución

Conceptos básicos de reflection es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué es la reflexión?

La reflexión es la capacidad de un programa para inspeccionar y manipular su propia estructura en tiempo de ejecución: clases, propiedades, funciones y anotaciones.

La reflexión de Kotlin se encuentra en el paquete kotlin.reflect y gira en torno a KClass.

Obtener una KClass

Use la sintaxis ::class sobre un tipo o una instancia para obtener su objeto KClass.

class Robot

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

Nombres de una clase

Una KClass expone simpleName y qualifiedName. El nombre cualificado incluye la ruta del paquete.

class Engine

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

Inspeccionar propiedades

memberProperties enumera las propiedades de una clase. Cada una es un KProperty cuyo name puede consultar.

import kotlin.reflect.full.memberProperties

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

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

Leer valores de propiedades

Puede llamar a un KProperty1 con una instancia para leer su valor mediante 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))
    }
}

Inspeccionar funciones

memberFunctions devuelve las funciones invocables de una clase como objetos KFunction. Puede leer el name de cada función.

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

Referencias a funciones

La sintaxis ::name produce una referencia invocable de tipo KFunction. Puede invocarla más tarde con invoke o pasarla a otra parte del programa.

fun double(n: Int) = n * 2

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

Crear instancias

createInstance() construye un objeto mediante reflexión cuando la clase tiene un constructor sin argumentos.

import kotlin.reflect.full.createInstance

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

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

Inspeccionar constructores

constructors enumera los constructores de la clase. Puede examinar sus parameters para saber qué argumentos esperan.

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

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

Costes y consideraciones

La reflexión es potente, pero:

Es más lenta que las llamadas directas
Omite la seguridad en tiempo de compilación
Requiere la biblioteca kotlin-reflect en la JVM

Úsela en frameworks y herramientas, no en bucles críticos.

La caja de herramientas de reflexión

Conviene recordar estos tipos principales:

KClass — una clase
KProperty — una propiedad
KFunction — una función
KParameter — un parámetro

Juntos permiten leer la estructura de forma dinámica.

Comprobación rápida

Compruebe cuánto ha entendido sobre los conceptos básicos de la reflexión.

Repaso

Ha aprendido los fundamentos de la reflexión:

Obtener una KClass mediante ::class
Enumerar memberProperties y memberFunctions
Leer valores de propiedades e invocar referencias a funciones
Construir objetos con createInstance()

A continuación: leer anotaciones dinámicamente.

Preguntas frecuentes

¿La lección «Conceptos básicos de reflection» es gratis?

Sí — el texto completo de «Conceptos básicos de reflection» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conceptos básicos de reflection»?

Inspeccione tipos en tiempo de ejecución Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Conceptos básicos de reflection»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy