Ce știi despre principiul proiecției stelare?

Principiul proiecției stelare (Star Projection) în Kotlin este o metodă sigură de utilizare a generice atunci când tipul specific al argumentului nu este important, dar trebuie asigurată siguranța tipurilor.

Se aplică în următoarele cazuri:

* : Echivalent cu Any?. Indică faptul că tipul argumentului este necunoscut și nu există informații despre limitele sale. Se pot citi doar elemente care sunt instanțe ale Any?, și nu se poate scrie nimic, în afară de null.
```
// Citire dintr-o listă cu tip necunoscut
fun readFromList(list: List<*>) {
    val item: Any? = list.firstOrNull()
    // Se poate citi în siguranță ca Any?
}
```
in * : Echivalent cu in Nothing. Este utilizat pentru tipuri covariate (out), atunci când tipul inferior specific nu este important. Se pot adăuga doar elemente (tipul Nothing, ceea ce este imposibil), dar nu se pot citi.
```
// Este imposibil să adaugi în siguranță elemente într-o listă covariantă
fun addToList(list: MutableList<out *>) {
    // list.add(...) // Nu se va compila
}
```

out * : Echivalent cu out Any?. Este utilizat pentru tipuri contravariate (in), atunci când tipul superior specific nu este important. Se pot citi doar elemente (ca Any?), dar nu se pot scrie.

// Citire dintr-un comparator cu tip contravariant
fun compare(comparator: Comparator<in *>) {
    // Se pot apela metode care NU acceptă tipul T
    // comparator.compare(obj1, obj2) // Nu se va compila fără conversie de tip
}

Scopul principal al proiecțiilor stelare este interacțiunea sigură cu clase și funcții generice, atunci când tipul complet al argumentului este necunoscut sau nu este relevant pentru operațiunea curentă. Acest lucru ajută la evitarea casturilor nesigure și la menținerea siguranței tipurilor.

Exemple de utilizare:

Lucrul cu colecții în care doar existența elementelor este importantă, dar nu și tipul lor specific.
Conversia tipurilor pentru obiecte generice.
Interoperabilitatea cu cod Java care utilizează tipuri brute.