Star projection en wanneer u * gebruikt
Pas star projection toe op onbekende generieke typen en begrijp de beperkingen ervan.
Star projection en wanneer u * gebruikt is een gratis Kotlin Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.
Wat is sterprojectie?
Sterprojectie (*) is Kotlin's manier om te zeggen: "een generiek type met een onbekend typeargument". Het is het veilige equivalent van Java's ruwe type of onbegrensde jokerteken <?>.
fun printList(list: List<*>) {
for (item in list) println(item)
}
fun main() {
printList(listOf(1, 2, 3))
printList(listOf("a", "b"))
printList(listOf(true, 42, "mixed"))
}Lezen uit typen met sterprojectie
Uit een List<*> kun je elementen lezen als Any?. Je kunt geen elementen toevoegen, omdat het werkelijke type onbekend is.
fun process(list: List<*>) {
val first: Any? = list.firstOrNull()
println("First: $first, Size: ${list.size}")
// list.add("x") // compile error: can't write to List<*>
}
fun main() {
process(listOf(10, 20, 30))
}Ster versus out Any
List<*> en List<out Any?> zijn equivalent. Sterprojectie is een verkorte notatie voor de covariante projectie met de bovengrens.
fun sumStars(list: List<*>): Int = list.size
fun sumOut(list: List<out Any?>): Int = list.size
fun main() {
val l = listOf(1, "two", true)
println(sumStars(l)) // 3
println(sumOut(l)) // 3
}Ster in functieparameters
Gebruik * in functiesignaturen wanneer je elke generieke variant moet accepteren, maar alleen methoden aanroept waarvoor kennis van T niet nodig is.
fun containerInfo(map: Map<*, *>): String {
return "keys=${map.keys.size}, values=${map.values.size}"
}
fun main() {
val m = mapOf(1 to "one", 2 to "two")
println(containerInfo(m))
}Ster met MutableList
Voor MutableList<*> kun je lezen als Any?, maar je kunt helemaal niets schrijven — de compiler voorkomt dit.
fun clearFirstElement(list: MutableList<*>) {
if (list.isNotEmpty()) {
list.removeAt(0) // OK: remove by index doesn't need T
// list.add("x") // Error: can't write unknown type
}
}
fun main() {
val m = mutableListOf(1, 2, 3)
clearFirstElement(m)
println(m) // [2, 3]
}Klasse met sterprojectie
Gebruik sterprojectie bij het controleren van een generiek klassetype tijdens runtime, omdat typeargumenten worden uitgewist.
fun isListOfSomething(obj: Any): Boolean {
return obj is List<*> // OK with star
// obj is List<String> // Warning: cannot check erased type
}
fun main() {
println(isListOfSomething(listOf(1, 2))) // true
println(isListOfSomething("not a list")) // false
}Meerdere sterparameters
Een functie kan meerdere parameters met sterprojectie hebben bij het werken met paren of mappen van onbekende typen.
fun describeMap(map: Map<*, *>) {
map.forEach { (k, v) ->
println("${k?.javaClass?.simpleName} -> ${v?.javaClass?.simpleName}")
}
}
fun main() {
describeMap(mapOf("key" to 42, 1 to true))
}Wanneer je sterprojectie NIET gebruikt
Vermijd sterprojectie wanneer je naar een verzameling moet schrijven of wanneer je in plaats daarvan een begrensde typeparameter kunt gebruiken — een begrensde typeparameter geeft je meer informatie.
// Bad: loses type information
fun addToStar(list: MutableList<*>, item: Any?) {
// list.add(item) // compile error
}
// Better: use bounded type parameter
fun <T : Any> addTyped(list: MutableList<T>, item: T) {
list.add(item)
}
fun main() {
val l = mutableListOf("a")
addTyped(l, "b")
println(l)
}Ster met typecontroles en conversies
Gebruik sterprojectie om instanceof-controles op generieke klassen uit te voeren en converteer daarna naar een specifiek type voor het echte werk.
fun handleResponse(response: Any) {
if (response is List<*>) {
val list = response as List<*>
println("List with ${list.size} elements")
val first = list.firstOrNull()
if (first is String) println("First string: $first")
}
}
fun main() {
handleResponse(listOf("hello", "world"))
handleResponse(42)
}Praktisch: generieke gebeurtenisverdeler
Een verdeler die elke Handler<*> accepteert, maar getypeerde gebeurtenissen veilig verdeelt.
interface Handler<in T> { fun handle(event: T) }
class LogHandler : Handler<Any> {
override fun handle(event: Any) = println("Event: $event")
}
fun dispatch(handler: Handler<*>, event: Any) {
@Suppress("UNCHECKED_CAST")
(handler as Handler<Any>).handle(event)
}
fun main() {
dispatch(LogHandler(), "click")
dispatch(LogHandler(), 42)
}Ster in reified-contexten
Sterprojectie komt vooral vaak voor in code voor reflectie en serialisatie, waarin het type tijdens runtime wordt geïnspecteerd via KClass<*>.
fun printClassName(klass: kotlin.reflect.KClass<*>) {
println(klass.simpleName)
}
fun main() {
printClassName(String::class) // String
printClassName(List::class) // List
printClassName(Int::class) // Int
}Korte controle
Welk type krijg je wanneer je uit een List<*> leest?
Samenvatting
Sterprojectie (*) accepteert elke generieke variant voor alleen-lezen-toegang. Gebruik dit voor typecontroles, generieke hulpprogramma's en reflectie. Vermijd het wanneer je naar een verzameling moet schrijven of wanneer een begrensde typeparameter betere typeveiligheid biedt.
Leer Kotlin met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 51
- Lessen
- 203
Veelgestelde vragen
Is de les “Star projection en wanneer u * gebruikt” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Star projection en wanneer u * gebruikt”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.
Wat leer ik in “Star projection en wanneer u * gebruikt”?
Pas star projection toe op onbekende generieke typen en begrijp de beperkingen ervan. Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Kotlin Academy te beginnen?
Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Star projection en wanneer u * gebruikt”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?
Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Generieke functies en typebeperkingen met where
- Variantie op declaraties: in en out
- Star projection en wanneer u * gebruikt
- Type-erasure en reified typeparameters