0Pricing
Kotlin Academy · Lekcja

Obiekty anonimowe i wyrażenia object

Używaj wyrażeń object do tworzenia jednorazowych implementacji interfejsów.

Obiekty anonimowe i wyrażenia object to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 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.

Wyrażenia obiektowe

Wyrażenie obiektowe tworzy anonimową, jednorazową instancję klasy lub interfejsu — jest odpowiednikiem anonimowych klas wewnętrznych z Javy, ale oferuje większe możliwości.

Anonimowe implementowanie interfejsu

Użyj zapisu object : Interface { ... }, aby utworzyć implementację w miejscu użycia.

interface ClickListener {
    fun onClick(): String
}
fun main() {
    val listener = object : ClickListener {
        override fun onClick() = "clicked!"
    }
    println(listener.onClick())
}

Anonimowa klasa ze stanem

Anonimowe obiekty mogą przechowywać stan i mieć wiele metod.

fun main() {
    val counter = object {
        var count = 0
        fun inc() { count++ }
        fun show() = println("count = $count")
    }
    counter.inc(); counter.inc(); counter.inc()
    counter.show()
}

Typ anonimowego obiektu

Typ anonimowego obiektu jest wywnioskowany. Gdy obiekt zostanie zadeklarowany na poziomie funkcji, zachowujesz dostęp do jego własnych elementów.

fun main() {
    val pair = object {
        val left = "L"
        val right = "R"
    }
    println("${pair.left} and ${pair.right}")
}

Ujawnianie typu anonimowego

Jeśli anonimowy obiekt jest zwracany z funkcji z wywnioskowanym typem, wywołujący widzą tylko nadtyp — dodatkowe elementy anonimowego obiektu są niedostępne z zewnątrz.

fun makeListener() = object {
    fun greet() = "hello"
}
fun main() {
    val l = makeListener()
    println(l.greet()) // OK — same compilation unit
}

Wiele interfejsów

Anonimowy obiekt może implementować wiele interfejsów w jednym wyrażeniu.

interface Closeable { fun close() }
interface Flushable { fun flush() }
fun main() {
    val resource = object : Closeable, Flushable {
        override fun close() = println("closed")
        override fun flush() = println("flushed")
    }
    resource.flush()
    resource.close()
}

Dziedziczenie po klasie

Anonimowe obiekty mogą dziedziczyć po otwartej klasie i przesłaniać jej elementy.

open class Animal(val name: String) {
    open fun speak() = "$name makes a sound"
}
fun main() {
    val pet = object : Animal("Rex") {
        override fun speak() = "$name barks!"
    }
    println(pet.speak())
}

Przechwytywanie zmiennych z otaczającego zakresu

Anonimowe obiekty zachowują dostęp do zmiennych w otaczającym zakresie (mogą je odczytywać i modyfikować) — w przeciwieństwie do wymogu użycia final w Javie.

fun main() {
    var log = mutableListOf<String>()
    val recorder = object {
        fun record(s: String) { log.add(s) }
    }
    recorder.record("event 1")
    recorder.record("event 2")
    println(log)
}

Kiedy używać anonimowych obiektów

Używaj anonimowych obiektów do jednorazowych implementacji, które nie zasługują na własną klasę — zwykle w przypadku wywołań zwrotnych, nasłuchiwaczy i komparatorów.

fun main() {
    val nums = listOf(3, 1, 4, 1, 5, 9, 2, 6)
    val sorted = nums.sortedWith(object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a // descending
    })
    println(sorted)
}

Gdy to możliwe, preferuj lambdy

Jeśli interfejs ma jedną abstrakcyjną metodę (SAM), lambda jest bardziej przejrzysta niż wyrażenie obiektowe.

fun main() {
    val nums = listOf(3, 1, 4, 1, 5, 9)
    // Old way:
    val sorted1 = nums.sortedWith(object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    })
    // New way — SAM conversion:
    val sorted2 = nums.sortedWith(Comparator { a, b -> b - a })
    println("$sorted1 / $sorted2")
}

Anonimowy a zadeklarowany obiekt

Użyj object Name dla nazwanego singletonu. Użyj object : Type w wyrażeniu, aby utworzyć jednorazową anonimową instancję.

// Named singleton (one instance, accessed globally)
object GlobalLogger { fun log(m: String) = println("[L] $m") }
// Anonymous (created at expression evaluation)
fun main() {
    val local = object { fun hi() = "hi" }
    GlobalLogger.log("hello")
    println(local.hi())
}

Szybkie sprawdzenie

Jaka składnia tworzy w miejscu użycia anonimową instancję implementującą interfejs?

Podsumowanie

Wyrażenia obiektowe tworzą w miejscu użycia jednorazowe, anonimowe instancje. Mogą implementować interfejsy, dziedziczyć po klasach, przechowywać stan i korzystać ze zmiennych w otaczającym zakresie. Preferuj lambdy dla interfejsów z jedną metodą; używaj wyrażeń obiektowych, gdy potrzebujesz wielu metod lub stanu.

Często zadawane pytania

Czy lekcja „Obiekty anonimowe i wyrażenia object” jest bezpłatna?

Tak — pełny tekst „Obiekty anonimowe i wyrażenia object” 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 „Obiekty anonimowe i wyrażenia object”?

Używaj wyrażeń object do tworzenia jednorazowych implementacji interfejsów. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Obiekty anonimowe i wyrażenia object”?

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

  1. Deklaracja object: singletony w Kotlinie
  2. companion object: elementy podobne do statycznych w Kotlinie
  3. Obiekty anonimowe i wyrażenia object
  4. Metody fabrykujące z companion object
← Powrót do Kotlin Academy