Kotlin Academy · Lezione

Nozioni di base sulla reflection

Esamini i tipi a runtime

Nozioni di base sulla reflection è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Che cos'è la reflection?

La reflection è la capacità di un programma di esaminare e manipolare la propria struttura a runtime: classi, proprietà, funzioni e annotazioni.

La reflection di Kotlin risiede nel package kotlin.reflect e ruota attorno a KClass.

Ottenere una KClass

Si usa la sintassi ::class su un tipo o un'istanza per ottenere il relativo oggetto KClass.

class Robot

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

Nomi di una classe

Una KClass espone simpleName e qualifiedName. Il nome qualificato include il percorso del package.

class Engine

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

Ispezionare le proprietà

memberProperties elenca le proprietà di una classe. Ognuna è un KProperty di cui è possibile leggere il 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)
    }
}

Leggere i valori delle proprietà

È possibile chiamare una KProperty1 con un'istanza per leggerne il valore tramite 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))
    }
}

Ispezionare le funzioni

memberFunctions restituisce le funzioni chiamabili di una classe sotto forma di oggetti KFunction. È possibile leggere il name di ogni funzione.

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

Riferimenti a funzioni

La sintassi ::name produce un riferimento chiamabile di tipo KFunction. È possibile invocarlo in seguito con invoke o passarlo ad altro codice.

fun double(n: Int) = n * 2

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

Creare istanze

createInstance() crea un oggetto tramite reflection quando la classe ha un costruttore senza argomenti.

import kotlin.reflect.full.createInstance

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

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

Ispezionare i costruttori

constructors elenca i costruttori della classe. È possibile esaminarne i parameters per sapere quali argomenti si aspettano.

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

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

Costi e aspetti da considerare

La reflection è potente, ma:

È più lenta delle chiamate dirette
Ignora la sicurezza fornita in fase di compilazione
Richiede la libreria kotlin-reflect sulla JVM

La si usi per framework e strumenti, non nei cicli più eseguiti.

Gli strumenti della reflection

Questi sono i tipi fondamentali da ricordare:

KClass — una classe
KProperty — una proprietà
KFunction — una funzione
KParameter — un parametro

Insieme consentono di leggere dinamicamente la struttura.

Verifica rapida

Verifichi la Sua comprensione delle basi della reflection.

Riepilogo

Ha imparato i fondamenti della reflection:

Ottenere una KClass tramite ::class
Elencare memberProperties e memberFunctions
Leggere i valori delle proprietà e invocare i riferimenti a funzioni
Creare oggetti con createInstance()

Prossimo argomento: leggere dinamicamente le annotazioni.

Domande Frequenti

La lezione «Nozioni di base sulla reflection» è gratuita?

Sì — il testo completo di «Nozioni di base sulla reflection» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Nozioni di base sulla reflection»?

Esamini i tipi a runtime Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Nozioni di base sulla reflection»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy