Kotlin Academy · leksjon

Generiske begrensninger

Begrens typeparametere

Leksjon 4 av 413 trinn

Generiske begrensninger er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Begrense typeparametere

Noen ganger må en generisk type bare godta bestemte typer, for eksempel typer som kan sammenlignes, eller typer som arver fra en basetype. Generiske begrensninger angir en øvre grense for en typeparameter.

Den standard øvre grensen

Uten en begrensning er den øvre grensen for en typeparameter Any?, så den godtar alle typer, også nullable typer. Hvis du bare vil tillate ikke-null-typer, begrenser du den til Any.

fun <T : Any> requireNonNull(value: T): T {
    return value
}

fun main() {
    println(requireNonNull(42))
}

Én øvre grense

Bruk T : Bound for å kreve at T er en sub-type av Bound. Da kan du kalle medlemmene til grensen inne i funksjonen.

fun <T : Number> sumDoubled(a: T, b: T): Double {
    return a.toDouble() * 2 + b.toDouble() * 2
}

fun main() {
    println(sumDoubled(3, 4))
    println(sumDoubled(1.5, 2.5))
}

Comparable-grense

En vanlig grense er Comparable<T>, som lar deg sammenligne elementer med <, > eller compareTo.

fun <T : Comparable<T>> maxOf2(a: T, b: T): T {
    return if (a > b) a else b
}

fun main() {
    println(maxOf2(3, 9))
    println(maxOf2("apple", "banana"))
}

Kalle medlemmer fra grensen

Inne i en begrenset generisk type vet kompilatoren at T har API-et til grensen, så du kan kalle disse metodene direkte uten å caste.

fun <T : CharSequence> describe(value: T): String {
    return "Length is ${value.length}"
}

fun main() {
    println(describe("hello"))
    println(describe(StringBuilder("hi")))
}

Flere grenser med where

For mer enn én grense bruker du where-setningen. T må da oppfylle ALLE de oppførte begrensningene.

fun <T> copyWhenValid(value: T): T
    where T : CharSequence, T : Comparable<T> {
    return value
}

fun main() {
    println(copyWhenValid("text"))
}

Grenser for klasser

Begrensninger fungerer også på generiske klasser og begrenser hvilke typer klassen kan instansieres med.

class NumberBox<T : Number>(val value: T) {
    fun asDouble(): Double = value.toDouble()
}

fun main() {
    val box = NumberBox(10)
    println(box.asDouble())
}

Begrensningen muliggjør operasjoner

Hele poenget med en begrensning er å åpne for operasjoner. Uten T : Number kunne du ikke kalt toDouble(); grensen garanterer at metoden finnes.

Ikke-null-grensen i praksis

En grense til Any avviser nullable argumenter ved kompilering. Det er en praktisk måte å kreve generiske typer som ikke kan være null.

fun <T : Any> firstNonNull(a: T, b: T): T = a

fun main() {
    println(firstNonNull("x", "y"))
    // firstNonNull(null, "y") would not compile
}

Kombinere med varians

Begrensninger og varians løser ulike problemer: varians (in/out) styrer subtypingsforhold, mens begrensninger (:-grenser, where) begrenser hvilke typer som er tillatt. De kan brukes sammen.

Utforme gode begrensninger

Legg bare til en begrensning når du trenger en egenskap fra typen. For strenge begrensninger reduserer gjenbrukbarheten, mens for svake begrensninger tvinger frem cast. Bruk den mest generelle typen som tilbyr operasjonene du bruker, som grense.

Kort kontrollspørsmål

Hvordan krever du at en typeparameter skal oppfylle mer enn én grense?

Besvar den i den interaktive leksjonen

Oppsummering

Generiske begrensninger angir øvre grenser med T : Bound (eller where for flere grenser), åpner for operasjonene til grensen og utelukker inkompatible typer. En grense til Any krever en ikke-null-type. Sammen med varians lar begrensninger deg utforme trygge og uttrykksfulle generiske typer. Dette fullfører kurset Generiske typer og varians.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Generiske begrensninger» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Generiske begrensninger», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Generiske begrensninger»?

Begrens typeparametere Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Generiske begrensninger»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Kotlin Academy