Android Academy · Lektion

Erweiterungs- und höherwertige Funktionen

Erweitern Sie bestehende Typen mit Extension Functions und verwenden Sie höherwertige Funktionen sowie Scope Functions (let, apply, also, run, with) für ausdrucksstarken Kotlin-Code.

Erweiterungs- und höherwertige Funktionen ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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 Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Erweiterungsfunktionen

Mit einer Erweiterungsfunktion können Sie bestehenden Klassen ohne Änderungen oder Vererbung neue Funktionen hinzufügen. Sie können String, Int, Ihre eigenen Klassen oder sogar Androids View erweitern.

Syntax: fun TypeName.functionName() { }

Erweiterungsfunktionen schreiben

Innerhalb einer Erweiterungsfunktion verweist this auf das Empfängerobjekt:

fun String.isPalindrome(): Boolean {
    val cleaned = this.lowercase().filter { it.isLetter() }
    return cleaned == cleaned.reversed()
}

fun Int.isEven() = this % 2 == 0

fun main() {
    println("racecar".isPalindrome())  // true
    println("hello".isPalindrome())    // false
    println(4.isEven())                // true
    println(7.isEven())                // false
}

Erweiterungsfunktionen für Android-Views

Ein gängiges Android-Muster: Views mit einer Erweiterung ein- und ausblenden, statt Boilerplate-Code zu wiederholen:

import android.view.View

fun View.show() { visibility = View.VISIBLE }
fun View.hide() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }

// Usage in Activity:
// binding.progressBar.show()
// binding.recyclerView.hide()

Funktionen höherer Ordnung

Eine Funktion höherer Ordnung nimmt eine Funktion als Parameter entgegen oder gibt eine Funktion zurück. Sie haben solche Funktionen bereits verwendet: filter, map und forEach sind allesamt Funktionen höherer Ordnung.

Syntax für Funktionstypen: (ParamType) -> ReturnType

Funktionen als Parameter übergeben

Definieren Sie eine Funktion, die eine andere Funktion entgegennimmt:

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum  = operate(3, 4) { x, y -> x + y }
    val prod = operate(3, 4) { x, y -> x * y }
    val max  = operate(3, 4, ::maxOf)   // method reference

    println(sum)   // 7
    println(prod)  // 12
    println(max)   // 4
}

Funktionen zurückgeben

Funktionen können auch andere Funktionen zurückgeben — das ist nützlich, um konfigurierbares Verhalten zu erstellen:

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)

    println(double(5))   // 10
    println(triple(5))   // 15

    val numbers = listOf(1, 2, 3, 4)
    println(numbers.map(double))  // [2, 4, 6, 8]
}

Scope-Funktionen: let

Kotlin-Scope-Funktionen führen einen Block für ein Objekt aus und geben ein Ergebnis zurück. let wird für Null-Prüfungen und Transformationen verwendet:

fun main() {
    val name: String? = "Alice"

    // Only runs if name is not null
    name?.let {
        println("Name length: ${it.length}")
        println("Upper: ${it.uppercase()}")
    }

    // Transform a value
    val length = name?.let { it.length } ?: 0
    println("Length: $length")  // 5
}

Scope-Funktionen: apply & also

apply konfiguriert ein Objekt und gibt das Objekt zurück. also führt einen Seiteneffekt aus und gibt das Objekt zurück:

data class Config(var host: String = "", var port: Int = 0, var timeout: Int = 0)

fun main() {
    // apply: configure an object (this = receiver)
    val config = Config().apply {
        host = "api.example.com"
        port = 443
        timeout = 30
    }
    println(config)  // Config(host=api.example.com, port=443, timeout=30)

    // also: log or debug (it = receiver)
    val result = listOf(1, 2, 3)
        .also { println("Original: $it") }
        .map { it * 2 }
        .also { println("Doubled: $it") }
}

Scope-Funktionen: run & with

run führt einen Block für ein Objekt aus und gibt das Ergebnis des Blocks zurück. with ist ähnlich, aber keine Erweiterungsfunktion:

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Bob", 30)

    // run: compute something using the object
    val greeting = user.run {
        if (age >= 18) "Hello, $name!" else "Hi, $name!"
    }
    println(greeting)  // Hello, Bob!

    // with: group operations on an object
    val info = with(user) {
        "Name: $name, Age: $age"
    }
    println(info)  // Name: Bob, Age: 30
}

Spickzettel zu Scope-Funktionen

Schnellreferenz zur Auswahl der richtigen Scope-Funktion:

let — null-sicherer Block, Objekt transformieren, gibt das Lambda-Ergebnis zurück
apply — Objekt konfigurieren, gibt das Objekt (this) zurück
also — Seiteneffekte (Protokollierung), gibt das Objekt (it) zurück
run — Ergebnis aus einem Objekt berechnen, gibt das Lambda-Ergebnis zurück
with — Aufrufe für ein Objekt gruppieren, keine Erweiterungsfunktion

inline-Funktionen & reified

Markieren Sie eine Funktion höherer Ordnung als inline, um die Erstellung eines Lambda-Objekts zur Laufzeit zu vermeiden. Mit reified können Sie den generischen Typ T zur Laufzeit verwenden (normalerweise wird er gelöscht):

inline fun <reified T> Any.isOfType(): Boolean = this is T

fun main() {
    println("hello".isOfType<String>())   // true
    println(42.isOfType<String>())         // false
    println(3.14.isOfType<Double>())       // true
}

Schnelltest

Welche Scope-Funktion eignet sich am besten, um ein neu erstelltes Objekt zu konfigurieren und genau dieses Objekt zurückzugeben?

Zusammenfassung: Erweiterungen & Funktionen höherer Ordnung

Das funktionale Kotlin-Werkzeugset steht Ihnen jetzt zur Verfügung:

Erweiterungsfunktionen — Verhalten zu jedem Typ hinzufügen, ohne Vererbung
Funktionen höherer Ordnung — Funktionen übergeben und zurückgeben, um flexible APIs zu erstellen
Scope-Funktionen: let (Null-Prüfung), apply (konfigurieren), also (Seiteneffekt), run/with (berechnen)
inline + reified — Lambdas ohne Laufzeitkosten mit Typinformationen zur Laufzeit

Als Nächstes: Erstellen Sie Apps mit mehreren Bildschirmen mithilfe von Fragments.

Häufig gestellte Fragen

Ist die Lektion „Erweiterungs- und höherwertige Funktionen“ kostenlos?

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

Was lerne ich in „Erweiterungs- und höherwertige Funktionen“?

Erweitern Sie bestehende Typen mit Extension Functions und verwenden Sie höherwertige Funktionen sowie Scope Functions (let, apply, also, run, with) für ausdrucksstarken Kotlin-Code. Du übst Android 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 Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android 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 4 von 4.

Wie lange dauert die Lektion „Erweiterungs- und höherwertige Funktionen“?

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 Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android 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

Null-Sicherheit
Klassen und Objekte
Datenklassen und versiegelte Klassen
Erweiterungs- und höherwertige Funktionen

← Zurück zu Android Academy