Generiska funktioner och klasser
Parametrisera typer
Generiska funktioner och klasser är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.
Vad är generiska typer
Generiska typer låter dig skriva kod som fungerar med många typer och samtidigt behåller full typsäkerhet. I stället för att låsa fast en konkret typ använder du en typparameter, ofta T, som platshållare.
En generisk funktion
En generisk funktion deklarerar sin typparameter inom vinkelparenteser före funktionsnamnet. Här kan T vara vilken typ som helst.
fun <T> identity(value: T): T {
return value
}
fun main() {
println(identity(42))
println(identity("hello"))
}Typinferens
Du behöver sällan ange typen uttryckligen; kompilatorn härleder T från argumenten. Du kan fortfarande skriva den som identity<Int>(42) om det behövs.
fun <T> firstOf(a: T, b: T): T = a
fun main() {
val x = firstOf(10, 20)
val y = firstOf("a", "b")
println("$x $y")
}Flera typparametrar
En funktion kan ha flera typparametrar, vilket är användbart när du arbetar med par av orelaterade typer.
fun <A, B> makePair(first: A, second: B): Pair<A, B> {
return Pair(first, second)
}
fun main() {
val p = makePair("age", 30)
println(p)
}En generisk klass
Klasser kan också vara generiska. Typparametern deklareras efter klassnamnet och kan användas för egenskaper och funktioner.
class Box<T>(val value: T) {
fun get(): T = value
}
fun main() {
val intBox = Box(123)
val strBox = Box("Kotlin")
println(intBox.get())
println(strBox.get())
}Generisk klass med beteende
Generiska klasser kan innehålla föränderliga tillstånd och arbeta med typparametern, till exempel som en enkel behållare.
class Stack<T> {
private val items = mutableListOf<T>()
fun push(item: T) { items.add(item) }
fun pop(): T = items.removeAt(items.size - 1)
fun isEmpty() = items.isEmpty()
}
fun main() {
val stack = Stack<Int>()
stack.push(1)
stack.push(2)
println(stack.pop())
}Generiska gränssnitt
Gränssnitt kan också deklarera typparametrar, så att implementationerna kan välja den konkreta typen.
interface Container<T> {
fun item(): T
}
class StringContainer : Container<String> {
override fun item(): String = "fixed"
}
fun main() {
println(StringContainer().item())
}Varför inte bara använda Any
Du kan lagra värden som Any, men då förlorar du typinformationen och behöver typomvandlingar. Generiska typer bevarar den exakta typen, så kompilatorn upptäcker fel och inga typomvandlingar behövs.
fun main() {
val box: Box<String> = Box("text")
val s: String = box.get()
println(s.uppercase())
}
class Box<T>(val value: T) { fun get(): T = value }Generiska utökningsfunktioner
Utökningsfunktioner kan vara generiska, vilket gör det möjligt att skapa återanvändbara verktyg för alla typer.
fun <T> T.printAndReturn(): T {
println("Value: $this")
return this
}
fun main() {
val x = 5.printAndReturn()
"hi".printAndReturn()
println(x)
}Namngivningskonventioner
Enligt konvention namnges typparametrar med enstaka versaler: T för en generell typ, E för ett element, K och V för nycklar och värden i en map och R för ett resultat.
Generiska typer överallt
Kotlins standardbibliotek bygger på generiska typer: List<T>, Map<K, V> och Pair<A, B>. Om du förstår generiska typer blir det lättare att läsa och använda dessa typer med självförtroende.
Snabbkontroll
Vilken är den främsta fördelen med generiska typer jämfört med att använda Any?
Sammanfattning
Generiska typer använder typparametrar som T för att skriva återanvändbara och typsäkra funktioner, klasser och gränssnitt. Kompilatorn härleder typer och upprätthåller säkerheten, så typomvandlingar kan undvikas. Därefter får du styra hur generiska typer förhåller sig till varandra med varians vid deklarationen med in och out.
Lär dig Kotlin med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 51
- Lektioner
- 203
Vanliga frågor
Är lektionen ”Generiska funktioner och klasser” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Generiska funktioner och klasser”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Kotlin Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Generiska funktioner och klasser”?
Parametrisera typer Ni övar på Kotlin Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Kotlin Academy?
Du behöver inga förkunskaper. Utbildningen i Kotlin Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Generiska funktioner och klasser”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Kotlin Academy-lektionen?
Ja. Varje Kotlin Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Generiska funktioner och klasser
- Varians vid deklaration
- Varians vid användning
- Generiska begränsningar