Generische Funktionen und Typbeschränkungen mit where
Schreiben Sie generische Funktionen mit einzelnen und mehreren Typbeschränkungen.
Generische Funktionen und Typbeschränkungen mit where 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.
Grundlagen generischer Funktionen
Generische Funktionen verwenden Typparameter in spitzen Klammern vor dem Funktionsnamen. Der Typparameter kann in Parameter- und Rückgabetypen verwendet werden.
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]
}Obere Schranken mit :-Constraint
Beschränken Sie einen Typparameter mit einer oberen Schranke mithilfe von :. Der Typ muss ein Subtyp der Schranke sein.
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 obere Schranke
Die standardmäßige obere Schranke ist Any? (nullable). Verwenden Sie T : Any, um null auszuschließen.
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) }
}Mehrere Einschränkungen mit where
Verwenden Sie die where-Klausel, um mehrere Einschränkungen auf einen einzelnen Typparameter anzuwenden.
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 bei einer Klasse
Die where-Klausel funktioniert auch bei Typparametern auf Klassenebene.
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
}Generische Extension-Funktionen
Auch Extension-Funktionen können Typparameter besitzen und stehen dadurch für bestimmte generische Typen zur Verfügung.
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
}Typparameter an der Rückgabeposition
Generische Funktionen können den Typ aus dem Kontext ableiten, sodass explizite Typargumente an der Aufrufstelle entfallen.
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
}Wiederverwendbare generische Hilfsfunktionen
Generische Funktionen machen Hilfsfunktionen über verschiedene Typen hinweg wiederverwendbar, ohne Code zu duplizieren.
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
}Star-Projektion vs. beschränkte Wildcard
Vergleichen Sie die Verwendung eines beschränkten Typparameters (nützlich, wenn Sie T erzeugen oder konsumieren müssen) mit einer Star-Projektion (wenn der Typ unbekannt ist).
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
}Generisches Vertauschen eines Pair
Eine einfache, aber anschauliche generische Funktion, die die Komponenten eines Pair vertauscht.
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)
}Praktisch: Generischer Result-Entwrapper
Verwenden Sie beschränkte Generics, um eine Hilfsfunktion zu schreiben, die ein Result<T> mit einer typisierten Transformation abbildet.
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)
}Schnelltest
Wie wenden Sie mehrere Einschränkungen auf einen Typparameter an?
Zusammenfassung
Generische Funktionen verwenden Typparameter, um wiederverwendbaren, typsicheren Code zu schreiben. Beschränken Sie einen Typ mit : auf eine einzelne Schranke oder mit where auf mehrere Schranken. Der Kotlin-Compiler setzt diese Einschränkungen an der Aufrufstelle durch.
Lerne Kotlin mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Generische Funktionen und Typbeschränkungen mit where“ kostenlos?
Ja — der vollständige Text von „Generische Funktionen und Typbeschränkungen mit where“ 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 Typbeschränkungen mit where“?
Schreiben Sie generische Funktionen mit einzelnen und mehreren Typbeschränkungen. 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 Typbeschränkungen mit where“?
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
- Generische Funktionen und Typbeschränkungen mit where
- Varianz an der Deklarationsstelle: in und out
- Star Projection und wann * verwendet wird
- Type Erasure und reifizierte Typparameter