Kotlin Academy · Lekcja

Klasy wewnętrzne

Uzyskuj dostęp do zewnętrznego zakresu

Lekcja 2 z 413 kroki

Klasy wewnętrzne to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Słowo kluczowe inner

Oznaczenie klasy zagnieżdżonej słowem inner zapewnia jej odwołanie do instancji klasy zewnętrznej, dzięki czemu może uzyskiwać dostęp do elementów klasy zewnętrznej.

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

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

Tworzenie instancji klasy wewnętrznej

Ponieważ klasa wewnętrzna potrzebuje instancji klasy zewnętrznej, należy utworzyć ją za jej pośrednictwem: Outer().Inner().

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

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

Dostęp do właściwości klasy zewnętrznej

Klasa wewnętrzna odczytuje właściwości klasy zewnętrznej i używa ich bezpośrednio, tak jakby były jej własnymi właściwościami.

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

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

Wywoływanie metod klasy zewnętrznej

Klasy wewnętrzne mogą również wywoływać metody instancji klasy zewnętrznej.

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

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

Składnia this@Outer

Aby jawnie odwołać się do instancji klasy zewnętrznej, na przykład w przypadku konfliktu nazw, należy użyć this@Outer.

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

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

Dlaczego używać inner?

Proszę używać inner, gdy zagnieżdżony typ rzeczywiście musi współpracować z konkretną instancją klasy zewnętrznej i współdzielić jej stan.

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

Każda klasa wewnętrzna jest powiązana z jedną klasą zewnętrzną

Instancja klasy wewnętrznej jest powiązana dokładnie z tą instancją klasy zewnętrznej, która ją utworzyła, dlatego zmiany są widoczne w tym obiekcie.

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

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

Klasa wewnętrzna a zagnieżdżona

Bez inner klasa zagnieżdżona jest odizolowana. Z inner przechwytuje instancję klasy zewnętrznej. To słowo kluczowe stanowi całą różnicę.

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

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

Uwaga dotycząca pamięci

Ponieważ instancja klasy wewnętrznej utrzymuje przy życiu instancję klasy zewnętrznej, w przypadku długowiecznych obiektów wewnętrznych należy zachować ostrożność, aby nie przetrzymywać tej instancji przez przypadek.

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

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

Realistyczny iterator

Klasa wewnętrzna doskonale nadaje się do iteratora, który przechodzi po stanie otaczającej go kolekcji.

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

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

Łączenie poznanych pojęć

Klasy wewnętrzne mogą korzystać ze stanu klasy zewnętrznej i usuwać niejednoznaczności za pomocą this@Outer.

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

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

Szybkie sprawdzenie

Proszę sprawdzić swoją znajomość klas wewnętrznych.

Odpowiedz w interaktywnej lekcji

Podsumowanie

W tej części poznali Państwo klasy wewnętrzne:

inner zapewnia dostęp do instancji klasy zewnętrznej i jej elementów.
Tworzy się je za pośrednictwem instancji klasy zewnętrznej: Outer().Inner().
Do odwołania do instancji obejmującej należy użyć this@Outer.
Instancje klas wewnętrznych utrzymują przy życiu instancję klasy zewnętrznej.

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

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

Bezpłatny start

Ucz się Kotlin dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 51
Lekcje: 203

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Klasy wewnętrzne” jest bezpłatna?

Tak — pełny tekst „Klasy wewnętrzne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Klasy wewnętrzne”?

Uzyskuj dostęp do zewnętrznego zakresu Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Klasy wewnętrzne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Kotlin Academy