Kotlin Academy · Les

Anonieme objecten

Inline-implementaties

Les 3 van 413 stappen

Anonieme objecten is een gratis Kotlin Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Implementaties op de plek zelf

Een anoniem object maakt een instantie van een klasse of interface zonder een nieuwe klasse een naam te geven. Gebruik daarvoor de object-expressie.

interface Greeter { fun greet(): String }

fun main() {
    val g = object : Greeter {
        override fun greet() = "Hi"
    }
    println(g.greet())
}

Een interface implementeren

Een objectexpressie kan een of meer interfaces implementeren precies op de plek waar dat nodig is.

interface Clickable { fun click() }

fun main() {
    val button = object : Clickable {
        override fun click() = println("Clicked")
    }
    button.click()
}

Leden van een klasse overschrijven

Je kunt anoniem een open klasse uitbreiden en leden overschrijven.

open class Animal { open fun sound() = "..." }

fun main() {
    val cat = object : Animal() {
        override fun sound() = "Meow"
    }
    println(cat.sound())
}

Extra status bijhouden

Een anoniem object mag naast de overschreven leden eigen eigenschappen declareren.

fun main() {
    val point = object {
        val x = 3
        val y = 4
    }
    println("${point.x}, ${point.y}")
}

Object zonder supertype

Als je een supertype weglaat, is het object gewoon een ad-hocbundel van leden, handig voor een snelle lokale groepering.

fun main() {
    val config = object {
        val retries = 3
        val timeout = 30
    }
    println(config.retries)
}

Lokale variabelen vastleggen

Anonieme objecten kunnen variabelen uit het omringende bereik vastleggen, in tegenstelling tot statisch geneste klassen.

fun makeCounter(start: Int): () -> Int {
    var count = start
    val obj = object {
        fun next() = count++
    }
    return { obj.next() }
}

fun main() {
    val c = makeCounter(10)
    println(c())
    println(c())
}

Als listener

Een veelvoorkomende toepassing is een implementatie op de plek zelf als terugroepfunctie of listener doorgeven.

interface OnDone { fun done(result: Int) }

fun compute(cb: OnDone) {
    cb.done(42)
}

fun main() {
    compute(object : OnDone {
        override fun done(result: Int) = println("Got $result")
    })
}

Type van een anoniem object

Wanneer een anoniem object door een functie wordt teruggegeven, is het afgeleide type het gedeclareerde supertype (of Any als er geen is). Extra leden zijn alleen lokaal zichtbaar.

interface Named { val name: String }

fun make(): Named = object : Named {
    override val name = "X"
}

fun main() {
    println(make().name)
}

Anonieme objecten versus lambda-expressies

Voor interfaces met één methode is een lambda korter, maar anonieme objecten zijn nodig wanneer je meerdere leden moet overschrijven of status moet bijhouden.

interface Handler {
    fun onStart()
    fun onStop()
}

fun main() {
    val h = object : Handler {
        override fun onStart() = println("start")
        override fun onStop() = println("stop")
    }
    h.onStart()
    h.onStop()
}

Objectexpressie versus objectdeclaratie

Een object-expressie maakt elke keer een nieuwe instantie. Een object-declaratie (object Name {}) is een benoemde singleton. Ze zien er vergelijkbaar uit, maar verschillen in levensduur.

object Singleton { val id = 1 }

fun main() {
    val fresh = object { val id = 2 }
    println(Singleton.id)
    println(fresh.id)
}

Een compacte vergelijker

Anonieme objecten zijn handig voor eenmalige vergelijkers of strategieën.

fun main() {
    val cmp = object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    }
    val list = listOf(1, 3, 2).sortedWith(cmp)
    println(list)
}

Korte test

Test je begrip van anonieme objecten.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt het volgende geleerd over anonieme objecten:

De object : Type {}-expressie maakt een naamloze instantie.
Ze kunnen interfaces implementeren, open klassen uitbreiden en status bijhouden.
Ze leggen lokale variabelen uit de omringende context vast.
Gebruik ze voor terugroepacties met meerdere methoden; geef voor één methode de voorkeur aan lambda's.

interface Run { fun go() }

fun main() {
    val r = object : Run { override fun go() = println("go") }
    r.go()
}

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Anonieme objecten” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Anonieme objecten”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “Anonieme objecten”?

Inline-implementaties Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Anonieme objecten”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Kotlin Academy