Kotlin Academy · Lektion

Lokale Klassen

Klassen in Funktionen

Lokale Klassen ist eine kostenlose Kotlin 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 Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Klassen in Funktionen

Kotlin ermöglicht es Ihnen, eine lokale Klasse innerhalb des Funktionskörpers zu deklarieren. Sie ist nur innerhalb dieser Funktion sichtbar.

fun main() {
    class Greeting(val text: String) {
        fun show() = println(text)
    }
    Greeting("Hello local").show()
}

Auf die Funktion beschränkt

Eine lokale Klasse kann außerhalb der Funktion, in der sie deklariert wurde, nicht verwendet werden. Dadurch bleiben Hilfstypen eng begrenzt.

fun build(): String {
    class Builder {
        fun make() = "built"
    }
    return Builder().make()
}

fun main() {
    println(build())
}

Lokale Variablen erfassen

Wie Closures können lokale Klassen Variablen aus der einschließenden Funktion erfassen.

fun main() {
    val prefix = ">> "
    class Logger {
        fun log(msg: String) = println(prefix + msg)
    }
    Logger().log("started")
}

Mehrere Instanzen

Sie können innerhalb der Funktion beliebig viele Instanzen einer lokalen Klasse erstellen.

fun main() {
    class Point(val x: Int)
    val a = Point(1)
    val b = Point(2)
    println(a.x + b.x)
}

Lokale Klasse mit Methoden

Lokale Klassen sind vollständige Klassen: Konstruktoren, Properties und Methoden funktionieren gleichermaßen.

fun main() {
    class Account(var balance: Int) {
        fun deposit(n: Int) { balance += n }
    }
    val acc = Account(100)
    acc.deposit(50)
    println(acc.balance)
}

Warum eine lokale Klasse verwenden?

Verwenden Sie eine lokale Klasse, wenn ein Hilfstyp nur innerhalb einer einzelnen Funktion sinnvoll ist. So vermeiden Sie, die Datei mit Top-Level-Typen zu überladen.

fun parseLine(line: String): Int {
    class Token(val value: String)
    val tokens = line.split(",").map { Token(it) }
    return tokens.size
}

fun main() {
    println(parseLine("a,b,c"))
}

Veränderlichen Zustand erfassen

Eine lokale Klasse kann erfasste veränderliche Variablen aus ihrem einschließenden Gültigkeitsbereich ändern.

fun main() {
    var total = 0
    class Adder {
        fun add(n: Int) { total += n }
    }
    val a = Adder()
    a.add(5)
    a.add(7)
    println(total)
}

Interfaces lokal implementieren

Lokale Klassen können Interfaces implementieren. Das ist nützlich, wenn Sie innerhalb einer Funktion eine benannte, wiederverwendbare Implementierung benötigen.

interface Step { fun run(): String }

fun main() {
    class First : Step {
        override fun run() = "first"
    }
    println(First().run())
}

Lokal oder anonym

Wählen Sie eine lokale Klasse, wenn Sie einen Namen benötigen, etwa um mehrere Instanzen zu erstellen oder auf den Typ zu verweisen. Wählen Sie ein anonymes Objekt für eine einzelne Inline-Instanz.

fun main() {
    class Repeater(val times: Int) {
        fun run() = "x".repeat(times)
    }
    println(Repeater(3).run())
}

Verschachtelung in Schleifen

Eine lokale Klasse kann sogar innerhalb von Blöcken wie Schleifen deklariert werden und ist dann auf diesen Block beschränkt.

fun main() {
    for (i in 1..2) {
        class Tag(val id: Int)
        println(Tag(i).id)
    }
}

Ein praktischer Helfer

Lokale Klassen eignen sich hervorragend für kurzlebige domänenspezifische Hilfstypen, die genau von einer Funktion verwendet werden.

fun report(values: List<Int>): String {
    class Stats(val sum: Int, val max: Int)
    val s = Stats(values.sum(), values.max())
    return "sum=${s.sum} max=${s.max}"
}

fun main() {
    println(report(listOf(3, 7, 2)))
}

Kurzer Test

Testen Sie Ihr Verständnis von lokalen Klassen.

Zusammenfassung

Sie haben lokale Klassen kennengelernt:

Sie werden innerhalb einer Funktion deklariert und sind auf diese beschränkt.
Sie können lokale Variablen aus dem einschließenden Gültigkeitsbereich erfassen und ändern.
Sie sind vollständige Klassen mit Konstruktoren, Properties, Methoden und Interfaces.
Verwenden Sie eine lokale Klasse, wenn Sie einen Namen benötigen, und ein anonymes Objekt für eine einzelne Inline-Instanz.

fun main() {
    val tag = "L"
    class C { fun show() = tag }
    println(C().show())
}

Häufig gestellte Fragen

Ist die Lektion „Lokale Klassen“ kostenlos?

Ja — der vollständige Text von „Lokale 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 „Lokale Klassen“?

Klassen in Funktionen 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 4 von 4.

Wie lange dauert die Lektion „Lokale 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