0Pricing
Kotlin Academy · Lezione

Reflection di Kotlin: KClass, KFunction, KProperty

Esplori i metadati delle classi con KClass e ne ispezioni i membri tramite reflection.

Reflection di Kotlin: KClass, KFunction, KProperty è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 1 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 permette al codice di ispezionare e invocare la propria struttura a runtime: classi, funzioni, proprietà, annotazioni e costruttori. Kotlin avvolge l'API di reflection della JVM con tipi propri e più ricchi nel package kotlin.reflect.

Ottenere una KClass

Usi ::class su un tipo o un'istanza per ottenere un riferimento KClass:

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

Proprietà di KClass

KClass espone i metadati della 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: riferimenti richiamabili

Usi ::functionName per ottenere un riferimento KFunction. Può ispezionarne i parametri e invocarlo:

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

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

Ispezionare i parametri

KFunction.parameters restituisce un elenco di oggetti KParameter con nome, tipo e indicazione di opzionalità:

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

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

KProperty: riferimenti alle proprietà

I riferimenti alle proprietà rappresentano una proprietà come oggetto di prima classe. KProperty0 è destinato alle proprietà senza receiver; KProperty1 alle proprietà 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"

Proprietà mutabili con KMutableProperty

Per le proprietà var, il riferimento è un KMutableProperty1, che dispone anche di una funzione 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

Elencare tutti i membri

KClass.members restituisce tutti i membri visibili (funzioni e proprietà). KClass.declaredMemberProperties restituisce solo le proprietà dichiarate in quella classe.

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

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

Creare istanze tramite KClass

Chiami KClass.createInstance() (richiede un costruttore senza argomenti) oppure usi KClass.constructors per avere il pieno controllo:

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

Dipendenza Kotlin Reflect

La reflection di Kotlin richiede l'artefatto kotlin-reflect (non incluso nella stdlib). Lo aggiunga alla build:

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

Nota sulle prestazioni

La reflection è significativamente più lenta del codice diretto. Memorizzi nella cache i riferimenti a KClass, KFunction e KProperty all'avvio. Eviti di chiamarli nei cicli ad alta frequenza. Per la maggior parte del codice di tooling e dei framework, questo costo è accettabile.

Verifica rapida

Quale tipo Kotlin rappresenta un riferimento a una proprietà membro e consente di leggerne il valore da un'istanza?

Riepilogo: reflection in Kotlin

Tipi principali:

  • KClass — metadati della classe, costruttori e membri
  • KFunction — riferimenti richiamabili, parametri e invocazione
  • KProperty1 / KMutableProperty1 — riferimenti alle proprietà, operazioni get/set
  • Richiede kotlin-reflect nel classpath
  • Memorizzare i riferimenti nella cache ed evitare di usarli nei percorsi ad alta frequenza

Domande Frequenti

La lezione «Reflection di Kotlin: KClass, KFunction, KProperty» è gratuita?

Sì — il testo completo di «Reflection di Kotlin: KClass, KFunction, KProperty» è 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 «Reflection di Kotlin: KClass, KFunction, KProperty»?

Esplori i metadati delle classi con KClass e ne ispezioni i membri tramite reflection. 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 1 di 4.

Quanto tempo richiede la lezione «Reflection di Kotlin: KClass, KFunction, KProperty»?

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

  1. Reflection di Kotlin: KClass, KFunction, KProperty
  2. Creare e applicare annotazioni personalizzate
  3. Leggere le annotazioni a runtime
  4. Validazione e mapping basati sulla reflection
← Torna a Kotlin Academy