Kotlin Academy · Lekcja

Klasy lokalne

Klasy w funkcjach

Klasy lokalne to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 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 w funkcjach

Kotlin pozwala deklarować klasę lokalną wewnątrz treści funkcji. Jest ona widoczna tylko w obrębie tej funkcji.

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

Zakres ograniczony do funkcji

Klasy lokalnej nie można używać poza funkcją, w której została zadeklarowana, dzięki czemu typy pomocnicze pozostają ściśle ograniczone do potrzebnego zakresu.

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

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

Przechwytywanie zmiennych lokalnych

Podobnie jak domknięcia, klasy lokalne mogą przechwytywać zmienne z funkcji obejmującej.

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

Wiele instancji

W obrębie funkcji można utworzyć dowolną liczbę instancji klasy lokalnej.

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

Klasa lokalna z metodami

Klasy lokalne są pełnoprawnymi klasami: działają w nich konstruktory, właściwości i metody.

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

Dlaczego używać klasy lokalnej?

Warto jej użyć, gdy typ pomocniczy ma znaczenie tylko wewnątrz jednej funkcji, aby uniknąć zaśmiecania pliku typami najwyższego poziomu.

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

Przechwytywanie zmiennego stanu

Klasa lokalna może modyfikować przechwycone zmienne, których wartość można zmieniać, z otaczającego ją zakresu.

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

Lokalne implementowanie interfejsów

Klasy lokalne mogą implementować interfejsy, co jest przydatne, gdy potrzebują Państwo nazwanej, wielokrotnie używanej implementacji wewnątrz jednej funkcji.

interface Step { fun run(): String }

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

Klasa lokalna a obiekt anonimowy

Proszę wybrać klasę lokalną, gdy potrzebna jest nazwa, na przykład do tworzenia wielu instancji lub odwoływania się do typu. Obiekt anonimowy sprawdzi się w przypadku pojedynczej instancji tworzonej w miejscu użycia.

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

Zagnieżdżanie wewnątrz pętli

Klasa lokalna może być nawet zadeklarowana wewnątrz bloków, takich jak pętle, a jej zakres będzie ograniczony do tego bloku.

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

Praktyczny typ pomocniczy

Klasy lokalne świetnie sprawdzają się jako krótkotrwałe typy pomocnicze dziedziny używane dokładnie przez jedną funkcję.

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

Szybkie sprawdzenie

Proszę sprawdzić swoją znajomość klas lokalnych.

Podsumowanie

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

Deklaruje się je wewnątrz funkcji, a ich zakres jest do niej ograniczony.
Mogą przechwytywać i modyfikować zmienne lokalne z otaczającego zakresu.
Są pełnoprawnymi klasami: mogą mieć konstruktory, właściwości, metody i implementować interfejsy.
Klasy lokalnej należy używać, gdy potrzebna jest nazwa, a obiektu anonimowego w przypadku pojedynczej instancji tworzonej w miejscu użycia.

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

Często zadawane pytania

Czy lekcja „Klasy lokalne” jest bezpłatna?

Tak — pełny tekst „Klasy lokalne” 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 lokalne”?

Klasy w funkcjach Ć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 4 z 4.

Ile czasu zajmuje lekcja „Klasy lokalne”?

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