Kotlin Academy · Lektion

Generische Funktionen und Klassen

Parametrisieren Sie Typen

Generische Funktionen und Klassen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Generics?

Generics ermöglichen es Ihnen, Code zu schreiben, der mit vielen Typen funktioniert und dabei vollständig typsicher bleibt. Anstatt einen konkreten Typ festzulegen, verwenden Sie einen Typparameter, häufig T, als Platzhalter.

Eine generische Funktion

Eine generische Funktion deklariert ihren Typparameter in spitzen Klammern vor dem Funktionsnamen. Hier kann T jeden Typ darstellen.

fun <T> identity(value: T): T {
    return value
}

fun main() {
    println(identity(42))
    println(identity("hello"))
}

Typinferenz

Meistens müssen Sie den Typ nicht ausdrücklich angeben; der Compiler leitet T aus den Argumenten ab. Bei Bedarf können Sie ihn trotzdem als identity<Int>(42) schreiben.

fun <T> firstOf(a: T, b: T): T = a

fun main() {
    val x = firstOf(10, 20)
    val y = firstOf("a", "b")
    println("$x $y")
}

Mehrere Typparameter

Eine Funktion kann mehrere Typparameter besitzen, was für die Arbeit mit Paaren unabhängiger Typen nützlich ist.

fun <A, B> makePair(first: A, second: B): Pair<A, B> {
    return Pair(first, second)
}

fun main() {
    val p = makePair("age", 30)
    println(p)
}

Eine generische Klasse

Auch Klassen können generisch sein. Der Typparameter wird nach dem Klassennamen deklariert und kann für Eigenschaften und Funktionen verwendet werden.

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())
}

Generische Klasse mit Verhalten

Generische Klassen können veränderlichen Zustand speichern und mit dem Typparameter arbeiten, etwa als einfacher Container.

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())
}

Generische Schnittstellen

Auch Schnittstellen können Typparameter deklarieren, sodass Implementierungen den konkreten Typ festlegen können.

interface Container<T> {
    fun item(): T
}

class StringContainer : Container<String> {
    override fun item(): String = "fixed"
}

fun main() {
    println(StringContainer().item())
}

Warum nicht einfach Any verwenden?

Sie könnten Werte als Any speichern, würden dabei aber Typinformationen verlieren und Umwandlungen benötigen. Generics bewahren den exakten Typ, sodass der Compiler Fehler erkennt und keine Umwandlungen erforderlich sind.

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 }

Generische Erweiterungsfunktionen

Erweiterungsfunktionen können generisch sein und dadurch wiederverwendbare Hilfsfunktionen für alle Typen ermöglichen.

fun <T> T.printAndReturn(): T {
    println("Value: $this")
    return this
}

fun main() {
    val x = 5.printAndReturn()
    "hi".printAndReturn()
    println(x)
}

Namenskonventionen

Üblicherweise werden Typparameter mit einzelnen Großbuchstaben benannt: T für einen generischen Typ, E für ein Element, K und V für Schlüssel und Werte einer Map sowie R für ein Ergebnis.

Generics überall

Kotlins Standardbibliothek basiert auf Generics: List<T>, Map<K, V>, Pair<A, B>. Wenn Sie Generics verstehen, können Sie diese Typen sicherer lesen und verwenden.

Kurzer Test

Was ist der wichtigste Vorteil von Generics gegenüber der Verwendung von Any?

Zusammenfassung

Generics verwenden Typparameter wie T, um wiederverwendbare und typsichere Funktionen, Klassen und Schnittstellen zu schreiben. Der Compiler leitet Typen ab und stellt die Typsicherheit sicher, sodass Umwandlungen vermieden werden. Als Nächstes steuern Sie mit der Varianz an der Deklarationsstelle und in und out, wie generische Typen zueinander in Beziehung stehen.

Häufig gestellte Fragen

Ist die Lektion „Generische Funktionen und Klassen“ kostenlos?

Ja — der vollständige Text von „Generische Funktionen und Klassen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Generische Funktionen und Klassen“?

Parametrisieren Sie Typen Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Generische Funktionen und Klassen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy