Kotlin Academy · Lezione

Definizione delle annotazioni

Crei annotazioni personalizzate

Definizione delle annotazioni è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Dichiarare un'annotazione

Si definisce un'annotazione con le parole chiave annotation class. La forma più semplice non contiene dati e funge da marcatore.

annotation class Beta

@Beta
fun newFeature() = "experimental"

fun main() {
    println(newFeature())
}

Parametri delle annotazioni

Le annotazioni possono contenere dati tramite i parametri del costruttore. I tipi consentiti sono limitati: primitivi, String, enumerazioni, altre annotazioni, KClass e array di questi tipi.

annotation class ApiVersion(val value: Int)

@ApiVersion(2)
fun endpoint() = "v2"

fun main() {
    println(endpoint())
}

@Target

@Target limita i punti in cui è possibile applicare l'annotazione. Si passano uno o più valori di AnnotationTarget, come CLASS, FUNCTION o PROPERTY.

@Target(AnnotationTarget.FUNCTION)
annotation class Loggable

@Loggable
fun process() = "processing"

fun main() {
    println(process())
}

@Retention

@Retention controlla per quanto tempo l'annotazione viene conservata:

SOURCE — viene scartata dal compilatore
BINARY — viene conservata nel file della classe, ma non è visibile tramite reflection
RUNTIME — viene conservata ed è visibile tramite reflection (impostazione predefinita)

@Retention(AnnotationRetention.RUNTIME)
annotation class Important

@Important
class Order

fun main() {
    println("Important is readable at runtime")
}

Più target

Si elencano più target per consentire l'uso di un'annotazione in più punti. In questo caso l'annotazione può essere applicata sia alle classi sia alle funzioni.

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
annotation class Audited

@Audited
class Account {
    @Audited
    fun withdraw() = "ok"
}

fun main() {
    println(Account().withdraw())
}

Valori predefiniti dei parametri

I parametri delle annotazioni possono avere valori predefiniti, quindi è possibile ometterli quando si usa l'annotazione. In questo modo i casi comuni rimangono concisi.

annotation class Cache(val seconds: Int = 60)

@Cache
fun cheap() = 1

@Cache(seconds = 300)
fun expensive() = 2

fun main() {
    println("" + cheap() + " " + expensive())
}

Parametri array

È possibile usare tipi array. Si forniscono i valori con la sintassi dei valori letterali degli array [ ... ] nell'uso dell'annotazione.

annotation class Roles(val names: Array<String>)

@Roles(["admin", "editor"])
fun restricted() = "secret"

fun main() {
    println(restricted())
}

@Repeatable

Per impostazione predefinita, un'annotazione può comparire una sola volta per elemento. La si contrassegna con @Repeatable per applicarla più volte.

@Repeatable
annotation class Tag(val value: String)

@Tag("db")
@Tag("cache")
fun layered() = "ok"

fun main() {
    println(layered())
}

Parametri di annotazioni annidate

Un parametro di un'annotazione può essere a sua volta un'altra annotazione, consentendo di creare metadati strutturati.

annotation class Author(val name: String)
annotation class Module(val owner: Author)

@Module(Author("Grace"))
class Payments

fun main() {
    println("Nested annotation metadata defined")
}

Progettare annotazioni efficaci

Un'annotazione ben progettata:

Ha uno scopo chiaro e unico
Imposta @Target, così un uso improprio diventa un errore di compilazione
Usa la conservazione RUNTIME solo quando è necessaria la reflection
Fornisce valori predefiniti sensati

Dalla definizione all'uso

Definire un'annotazione è solo metà del lavoro. Da sola è un metadato inerte. Qualcosa deve leggerla: di solito la reflection a runtime o un processore di annotazioni in fase di compilazione. Presto userà la reflection.

Verifica rapida

Verifichi la Sua comprensione della definizione delle annotazioni.

Riepilogo

Ha imparato a definire le annotazioni:

annotation class con parametri
@Target per limitarne l'applicazione
@Retention per controllarne la durata
@Repeatable e valori predefiniti

Prossimo argomento: ispezionare i tipi con la reflection.

Domande Frequenti

La lezione «Definizione delle annotazioni» è gratuita?

Sì — il testo completo di «Definizione delle annotazioni» è 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 «Definizione delle annotazioni»?

Crei annotazioni personalizzate 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 2 di 4.

Quanto tempo richiede la lezione «Definizione delle annotazioni»?

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