Kotlin Academy · Lektion

Innere Klassen

Greifen Sie auf den äußeren Gültigkeitsbereich zu

Innere Klassen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Das Schlüsselwort inner

Wenn Sie eine verschachtelte Klasse mit inner markieren, erhält sie eine Referenz auf die äußere Instanz und kann dadurch auf die Member der äußeren Klasse zugreifen.

class Outer {
    val msg = "Hello"
    inner class Inner {
        fun show() = msg
    }
}

fun main() {
    println(Outer().Inner().show())
}

Eine innere Instanz erstellen

Da eine innere Klasse eine äußere Instanz benötigt, erstellen Sie sie aus einer solchen Instanz heraus: Outer().Inner().

class Engine {
    val power = 100
    inner class Turbo {
        fun boosted() = power * 2
    }
}

fun main() {
    println(Engine().Turbo().boosted())
}

Auf Properties der äußeren Klasse zugreifen

Eine innere Klasse kann direkt auf Properties der äußeren Klasse zugreifen und sie verwenden, als wären es ihre eigenen.

class Counter {
    var count = 0
    inner class Stepper {
        fun step() { count++ }
    }
}

fun main() {
    val c = Counter()
    c.Stepper().step()
    println(c.count)
}

Methoden der äußeren Klasse aufrufen

Innere Klassen können ebenfalls Methoden der einschließenden Instanz aufrufen.

class Printer {
    fun line(s: String) = println(s)
    inner class Job {
        fun run() = line("printing")
    }
}

fun main() {
    Printer().Job().run()
}

Die Syntax this@Outer

Um ausdrücklich auf die äußere Instanz zu verweisen, beispielsweise bei Namenskonflikten, verwenden Sie this@Outer.

class Outer {
    val value = 10
    inner class Inner {
        val value = 20
        fun outerValue() = this@Outer.value
    }
}

fun main() {
    println(Outer().Inner().outerValue())
}

Warum inner verwenden?

Verwenden Sie inner, wenn der verschachtelte Typ tatsächlich mit einer bestimmten äußeren Instanz zusammenarbeiten und deren Zustand gemeinsam nutzen muss.

class Wallet {
    var balance = 50
    inner class Transaction(val amount: Int) {
        fun apply() { balance += amount }
    }
}

fun main() {
    val w = Wallet()
    w.Transaction(25).apply()
    println(w.balance)
}

Jede innere Instanz ist an eine äußere gebunden

Eine innere Instanz ist an genau die äußere Instanz gebunden, von der sie erstellt wurde; Änderungen wirken sich auf dieses Objekt aus.

class Box(var size: Int) {
    inner class Resizer {
        fun grow() { size += 1 }
    }
}

fun main() {
    val b = Box(3)
    b.Resizer().grow()
    println(b.size)
}

Inner oder verschachtelt

Ohne inner ist eine verschachtelte Klasse unabhängig. Mit inner übernimmt sie die äußere Instanz. Das Schlüsselwort macht den gesamten Unterschied.

class Outer {
    val tag = "X"
    inner class A { fun get() = tag }
}

fun main() {
    println(Outer().A().get())
}

Hinweis zum Speicher

Da eine innere Instanz die äußere Instanz am Leben hält, sollten Sie bei langlebigen inneren Objekten vorsichtig sein, um das unbeabsichtigte Festhalten des äußeren Objekts zu vermeiden.

class Service {
    val id = 1
    inner class Worker { fun who() = id }
}

fun main() {
    println(Service().Worker().who())
}

Ein realistischer Iterator

Eine innere Klasse eignet sich hervorragend für einen Iterator, der den Zustand seiner einschließenden Collection durchläuft.

class Stack {
    private val items = mutableListOf(1, 2, 3)
    inner class Reader {
        fun all() = items.joinToString()
    }
}

fun main() {
    println(Stack().Reader().all())
}

Die Konzepte kombinieren

Innere Klassen können den Zustand der äußeren Klasse verwenden und mit this@Outer zwischen gleichnamigen Bezeichnern unterscheiden.

class Outer {
    val n = 5
    inner class Inner {
        fun doubled() = this@Outer.n * 2
    }
}

fun main() {
    println(Outer().Inner().doubled())
}

Kurzer Test

Testen Sie Ihr Verständnis von inneren Klassen.

Zusammenfassung

Sie haben innere Klassen kennengelernt:

inner gewährt Zugriff auf die äußere Instanz und deren Member.
Sie werden über eine äußere Instanz erstellt: Outer().Inner().
Verwenden Sie this@Outer, um auf die einschließende Instanz zu verweisen.
Innere Instanzen halten ihre äußere Instanz am Leben.

class Outer {
    val v = 1
    inner class Inner { fun get() = v }
}

fun main() {
    println(Outer().Inner().get())
}

Häufig gestellte Fragen

Ist die Lektion „Innere Klassen“ kostenlos?

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

Greifen Sie auf den äußeren Gültigkeitsbereich zu 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 2 von 4.

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