PricingLoginStart free
Kotlin Academy · Lektion

Generiske funktioner og typebegrænsninger med where

Skriv generiske funktioner med én eller flere typebegrænsninger.

Lektion 1 af 413 trin

Generiske funktioner og typebegrænsninger med where er en gratis Kotlin Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Kotlin Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Grundlæggende om generiske funktioner

Generiske funktioner bruger typeparametre i vinkelparenteser før funktionsnavnet. Typeparameteren kan bruges i parametertyper og returtyper.

fun <T> identity(value: T): T = value
fun <T> listOf2(a: T, b: T): List<T> = listOf(a, b)
fun main() {
    println(identity(42))       // 42
    println(identity("hello"))  // hello
    println(listOf2(1, 2))      // [1, 2]
}

Øvre grænser med :-begrænsning

Begræns en typeparameter med en øvre grænse ved hjælp af :. Typen skal være en undertype af grænsen.

fun <T : Comparable<T>> max(a: T, b: T): T = if (a >= b) a else b
fun main() {
    println(max(3, 7))          // 7
    println(max("apple", "banana")) // banana
    // max(listOf(1), listOf(2)) // error: List is not Comparable
}

Nullable øvre grænse

Den standardmæssige øvre grænse er Any? (kan være null). Brug T : Any for at udelukke null.

fun <T : Any> notNull(value: T?): T {
    return value ?: throw IllegalArgumentException("Value is null")
}
fun main() {
    println(notNull("hello"))  // hello
    try { notNull(null) } catch (e: Exception) { println(e.message) }
}

Flere begrænsninger med where

Brug where-klausulen til at anvende flere begrænsninger på en enkelt typeparameter.

fun <T> process(item: T): String
        where T : Comparable<T>, T : CharSequence {
    return "Length=${item.length}, sorted=${item > "a"}"
}
fun main() {
    println(process("kotlin")) // Length=6, sorted=true
    // process(42) // error: Int doesn't implement CharSequence
}

where på en klasse

where-klausulen fungerer også med typeparametre på klasseniveau.

class SortedContainer<T>(private val items: MutableList<T> = mutableListOf())
        where T : Comparable<T>, T : Any {
    fun add(item: T) { items.add(item); items.sort() }
    fun top(): T? = items.lastOrNull()
}
fun main() {
    val c = SortedContainer<Int>()
    c.add(5); c.add(2); c.add(8)
    println(c.top()) // 8
}

Generiske udvidelsesfunktioner

Udvidelsesfunktioner kan også have typeparametre, så de bliver tilgængelige for bestemte generiske typer.

fun <T : Comparable<T>> List<T>.second(): T? {
    return if (size >= 2) this[1] else null
}
fun main() {
    println(listOf(10, 20, 30).second()) // 20
    println(listOf("a").second())        // null
}

Typeparameter i returposition

Generiske funktioner kan udlede typen fra konteksten, så du slipper for eksplicitte typeargumenter på kaldestedet.

fun <T> MutableList<T>.popOrDefault(default: T): T {
    return if (isEmpty()) default else removeAt(lastIndex)
}
fun main() {
    val list = mutableListOf(1, 2, 3)
    println(list.popOrDefault(0)) // 3
    println(list.popOrDefault(0)) // 2
    println(mutableListOf<Int>().popOrDefault(-1)) // -1
}

Genanvendelige generiske hjælpefunktioner

Generiske funktioner gør hjælpefunktioner genanvendelige på tværs af typer uden duplikering.

fun <T> Iterable<T>.firstOrElse(default: T): T = firstOrNull() ?: default
fun <T, R : Comparable<R>> Iterable<T>.maxByOrElse(selector: (T) -> R, default: T): T =
    maxByOrNull(selector) ?: default
fun main() {
    println(listOf<String>().firstOrElse("fallback")) // fallback
    println(listOf("a","bbb","cc").maxByOrElse({ it.length }, "")) // bbb
}

Stjerneprojektion kontra afgrænset jokertegn

Sammenlign brugen af en afgrænset typeparameter (nyttig, når du skal producere eller modtage T) med stjerneprojektion (når typen er ukendt).

fun <T : Number> sumList(list: List<T>): Double =
    list.sumOf { it.toDouble() }
// Star projection: read-only, type unknown
fun printAll(list: List<*>) = list.forEach { println(it) }
fun main() {
    println(sumList(listOf(1, 2, 3)))    // 6.0
    printAll(listOf("a", 1, true))       // a, 1, true
}

Generisk ombytning af Pair

En enkel, men illustrativ generisk funktion, der bytter delene i en Pair.

fun <A, B> Pair<A, B>.swap(): Pair<B, A> = Pair(second, first)
fun main() {
    val pair = Pair("hello", 42)
    val swapped = pair.swap()
    println(swapped) // (42, hello)
}

Praktisk: Generisk Result-udpakker

Brug afgrænsede generiske typer til at skrive en hjælpefunktion, der anvender en typet transformation på en Result<T>.

fun <T : Any, R : Any> Result<T>.mapNotNull(transform: (T) -> R?): Result<R> {
    return fold(
        onSuccess = { v ->
            val r = transform(v)
            if (r != null) Result.success(r) else Result.failure(NoSuchElementException())
        },
        onFailure = { Result.failure(it) }
    )
}
fun main() {
    val r = Result.success("123")
    val n = r.mapNotNull { it.toIntOrNull() }
    println(n) // Success(123)
}

Hurtigt tjek

Hvordan anvender du flere begrænsninger på én typeparameter?

Besvar den i den interaktive lektion

Opsummering

Generiske funktioner bruger typeparametre til at skrive genanvendelig, typesikker kode. Brug : til én enkelt grænse eller where til flere grænser. Kotlin-kompileren håndhæver begrænsningerne på kaldestedet.

Gratis at komme i gang

Lær Kotlin med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
51
Lektioner
203
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Generiske funktioner og typebegrænsninger med where” gratis?

Ja — alle 3 lektioner i læringssporet Kotlin Academy, inklusive “Generiske funktioner og typebegrænsninger med where”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Generiske funktioner og typebegrænsninger med where”?

Skriv generiske funktioner med én eller flere typebegrænsninger. Du øver dig i Kotlin Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Kotlin Academy?

Der kræves ingen tidligere erfaring. Kotlin Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Generiske funktioner og typebegrænsninger med where”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Kotlin Academy-lektion?

Ja. Alle Kotlin Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Generiske funktioner og typebegrænsninger med where
  2. Varians ved deklarationsstedet: in og out
  3. Star projection og hvornår * skal bruges
  4. Type-erasure og reified-typeparametre
← Tilbage til Kotlin Academy