Kotlin
Merkloos product
Zoeken…
Invoering
Een lijst kan cijfers, woorden of echt alles bevatten. Daarom noemen we de Lijst generiek .
Generieken worden in principe gebruikt om te bepalen welke typen een klasse kan bevatten en welk type een object momenteel bevat.
Syntaxis
- class ClassName < TypeName >
- class ClassName <*>
- ClassName <in UpperBound >
- ClassName <uit LowerBound >
- class Name < TypeName : UpperBound >
parameters
| Parameter | Details |
|---|---|
| TypeName | Type Naam van generieke parameter |
| Bovengrensconcentraties | Covariant Type |
| benedengrens | Contravariant type |
| Naam van de klasse | Naam van de klas |
Opmerkingen
Impliciet Upper Bound is Nullable
In Kotlin Generics is de bovengrens van typeparameter T Any? . Daarom voor deze klasse:
class Consumer<T>
De parameter type T is echt T: Any? . Om een niet-nulbare bovengrens te maken, expliciet specifiek T: Any . Bijvoorbeeld:
class Consumer<T: Any>
Declaratie-site variantie
Declaratie-site variantie kan worden beschouwd als een verklaring van gebruik-site variantie voor eens en altijd voor alle gebruik-sites.
class Consumer<in T> { fun consume(t: T) { ... } }
fun charSequencesConsumer() : Consumer<CharSequence>() = ...
val stringConsumer : Consumer<String> = charSequenceConsumer() // OK since in-projection
val anyConsumer : Consumer<Any> = charSequenceConsumer() // Error, Any cannot be passed
val outConsumer : Consumer<out CharSequence> = ... // Error, T is `in`-parameter
Veel voorkomende voorbeelden van de variantie van de declaratie-site zijn List<out T> , die onveranderlijk is zodat T alleen als het retourwaardetype verschijnt, en Comparator<in T> , die alleen T als argument ontvangt.
Gebruik-site variantie
De variantie van de gebruikssite is vergelijkbaar met Java-jokertekens:
Out-projectie:
val takeList : MutableList<out SomeType> = ... // Java: List<? extends SomeType>
val takenValue : SomeType = takeList[0] // OK, since upper bound is SomeType
takeList.add(takenValue) // Error, lower bound for generic is not specified
In projectie:
val putList : MutableList<in SomeType> = ... // Java: List<? super SomeType>
val valueToPut : SomeType = ...
putList.add(valueToPut) // OK, since lower bound is SomeType
putList[0] // This expression has type Any, since no upper bound is specified
Star-projectie
val starList : MutableList<*> = ... // Java: List<?>
starList[0] // This expression has type Any, since no upper bound is specified
starList.add(someValue) // Error, lower bound for generic is not specified
Zie ook:
Variant Generics interoperabiliteit bij het bellen van Kotlin vanuit Java.
