Cum să folosești adnotările în Kotlin?

Anotațiile în Kotlin sunt utilizate pentru a adăuga metainformații la clase, proprietăți, funcții, expresii și parametri. Ele nu execută o acțiune directă, dar pot fi utilizate de compilator, framework-uri sau alte biblioteci pentru diferite procesări.

Aspecte principale ale utilizării:

Sintaxă: Anotațiile sunt plasate înaintea elementului la care se aplică, în paranteze unghiulare @. Dacă anotația are parametri, aceștia sunt specificați în paranteze după nume.
```
@Deprecated("Use newFunction instead")
fun oldFunction() {
    // ...
}

@JvmStatic
fun staticMethod() {
    // ...
}
```

Aplicarea la diferiți membri: Anotațiile pot fi aplicate la:

Clase (class):

@Serializable
class User(val name: String)

Proprietăți (val, var):

@Inject
lateinit var userRepository: UserRepository

Funcții (fun):

@Test
fun testSomething() {
    // ...
}

Parametri ai constructorilor/funcțiilor:

fun processUser(@NotNull user: User) {
    // ...
}

Expresii:

fun calculate(@Ignore parameter: Int) {
    // ...
}

Tipuri (@Target(AnnotationTarget.TYPE)):

val list: @NotNull List<String> = emptyList()

Locuri de aplicare (Use-site Targets): Pentru disambiguarea elementului la care se aplică anotația, când există mai multe (de exemplu, câmp și getter), se folosesc use-site targets.

Target	Descriere
`@file:`	Se aplică întregului fișier
`@property:`	Se aplică întregii proprietăți
`@field:`	Se aplică câmpului de backing (backing field)
`@get:`	Se aplică getter-ului proprietății
`@set:`	Se aplică setter-ului proprietății
`@param:`	Se aplică parametrului constructorului
`@setparam:`	Se aplică parametrului setter-ului proprietății
`@delegate:`	Se aplică instanței proprietății delegate
`@receiver:`	Se aplică tipului receptorului

class Example(@field:Inject val dependency: Dependency) {
    // @field:Inject se aplică câmpului 'dependency'
}

Declarația propriilor anotații: Anotațiile personalizate sunt declarate cu cuvântul cheie annotation class. Parametrii anotației pot fi de tip primitive, string-uri, clase (KClass), enumerări, alte anotații sau array-uri ale acestor tipuri.
```
annotation class MyAnnotation(val value: String, val count: Int = 0)

@MyAnnotation("Hello", count = 5)
class AnnotatedClass {
    // ...
}
```
Meta-anotații: Anotațiile pot fi marcate cu meta-anotații, care definesc comportamentul și aplicabilitatea lor.
- @Target: Indică elementele care pot fi annotate.
- @Retention: Indică etapa în care anotația este prezentă (SOURCE, BINARY, RUNTIME).
- @Repeatable: Permite aplicarea repetată a aceleiași anotații.
- @MustBeDocumented: Indică faptul că anotația trebuie să fie parte a API-ului public generat de instrumente de documentare.
```
@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class ProcessedByFramework
```

Anotațiile sunt larg utilizate în Kotlin pentru integrarea cu framework-uri JVM (Spring, Android), serializare (Kotlinx.serialization), testare (JUnit) și crearea de biblioteci proprii, bazate pe metainformație.