Kotlin Academy · Lekcja

Klasy zagnieżdżone

Klasy wewnątrz klas

Klasy zagnieżdżone to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 1 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.

Klasy wewnątrz klas

Kotlin pozwala deklarować klasę wewnątrz innej klasy. Domyślnie taka klasa jest zagnieżdżona i nie przechowuje referencji do instancji zewnętrznej.

class Outer {
    class Nested {
        fun hello() = "Hi from Nested"
    }
}

fun main() {
    println(Outer.Nested().hello())
}

Tworzenie instancji zagnieżdżonej

Ponieważ klasa zagnieżdżona jest niezależna, tworzy się ją za pomocą nazwy klasy zewnętrznej, bez instancji zewnętrznej: Outer.Nested().

class Computer {
    class Cpu {
        val cores = 8
    }
}

fun main() {
    val cpu = Computer.Cpu()
    println(cpu.cores)
}

Brak dostępu do elementów klasy zewnętrznej

Klasa zagnieżdżona nie może uzyskać dostępu do elementów instancji klasy zewnętrznej, ponieważ nie ma referencji do klasy zewnętrznej. Zachowuje się jak klasa najwyższego poziomu objęta zakresem nazwy.

class Bank {
    val name = "ACME"
    class Branch {
        fun describe() = "A branch"
    }
}

fun main() {
    println(Bank.Branch().describe())
}

Po co w ogóle używać klas zagnieżdżonych?

Zagnieżdżanie wyraża logiczne grupowanie: typ wewnętrzny należy pojęciowo do typu zewnętrznego, co poprawia organizację i przestrzeń nazw.

class Http {
    class Request(val url: String)
}

fun main() {
    val r = Http.Request("/home")
    println(r.url)
}

Klasa zagnieżdżona z właściwościami

Klasy zagnieżdżone to zwykłe klasy: mogą mieć konstruktory, właściwości i metody.

class Garage {
    class Car(val model: String) {
        fun honk() = "$model: beep"
    }
}

fun main() {
    println(Garage.Car("Tesla").honk())
}

Dostęp do elementów companion i podobnych do statycznych

Do klas zagnieżdżonych można odwoływać się z dowolnego miejsca za pomocą nazwy klasy zewnętrznej, podobnie jak do statycznej klasy zagnieżdżonej w Javie.

class Config {
    class Defaults {
        val timeout = 30
    }
}

fun main() {
    println(Config.Defaults().timeout)
}

Wiele klas zagnieżdżonych

Klasa zewnętrzna może zawierać kilka klas zagnieżdżonych, aby grupować powiązane typy.

class Shapes {
    class Circle(val r: Int)
    class Square(val side: Int)
}

fun main() {
    println(Shapes.Circle(5).r)
    println(Shapes.Square(4).side)
}

Zagnieżdżanie w zagnieżdżeniu

Można zagnieżdżać klasy na więcej niż jednym poziomie, choć zbyt głębokie zagnieżdżenie może pogorszyć czytelność.

class A {
    class B {
        class C {
            val value = 42
        }
    }
}

fun main() {
    println(A.B.C().value)
}

Klasa zagnieżdżona a klasa najwyższego poziomu

Funkcjonalnie klasa zagnieżdżona przypomina klasę najwyższego poziomu; jedyną różnicą jest jej nazwa kwalifikowana. Proszę wybierać zagnieżdżenie wtedy, gdy relacja między typami poprawia czytelność.

class Order {
    class Item(val price: Int)
}

fun main() {
    val total = Order.Item(10).price + Order.Item(5).price
    println(total)
}

Praktyczne grupowanie

Umieszczenie typu wyniku buildera wewnątrz jego właściciela jest naturalne w odbiorze.

class Parser {
    class Result(val ok: Boolean, val message: String)

    fun parse(text: String) = Result(text.isNotEmpty(), "parsed")
}

fun main() {
    val res = Parser().parse("data")
    println("${res.ok} ${res.message}")
}

Najważniejsza zasada

Słowem kluczowym, które sprawia, że klasa przechowuje odwołanie do obiektu klasy zewnętrznej, jest inner. Bez niego klasa zagnieżdżona zachowuje się jak statyczna i jest odizolowana.

class Box {
    class Lid
}

fun main() {
    println(Box.Lid() != null)
}

Szybkie sprawdzenie

Proszę sprawdzić swoją znajomość klas zagnieżdżonych.

Podsumowanie

W tej części poznali Państwo klasy zagnieżdżone:

Deklaruje się je wewnątrz innej klasy, a domyślnie używa się class (klasa zagnieżdżona).
Nie mają odwołania do instancji klasy zewnętrznej, więc nie mogą uzyskiwać dostępu do jej elementów.
Tworzy się je za pomocą nazwy klasy zewnętrznej: Outer.Nested().
Świetnie nadają się do logicznego grupowania i tworzenia przestrzeni nazw.

class Outer {
    class Nested { val x = 1 }
}

fun main() {
    println(Outer.Nested().x)
}

Często zadawane pytania

Czy lekcja „Klasy zagnieżdżone” jest bezpłatna?

Tak — pełny tekst „Klasy zagnieżdżone” 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 zagnieżdżone”?

Klasy wewnątrz klas Ć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 1 z 4.

Ile czasu zajmuje lekcja „Klasy zagnieżdżone”?

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