Kotlin Academy · Lezione

Oggetti anonimi

Implementazioni inline

Oggetti anonimi è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Implementazioni inline

Un oggetto anonimo crea un’istanza di una classe o di un’interfaccia senza definire una nuova classe con nome. Utilizzi l’espressione object.

interface Greeter { fun greet(): String }

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

Implementazione di un’interfaccia

Un’espressione object può implementare una o più interfacce direttamente nel punto in cui serve.

interface Clickable { fun click() }

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

Override dei membri di una classe

È possibile creare una sottoclasse anonima di una classe open ed eseguire l’override dei suoi membri.

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

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

Conservazione di stato aggiuntivo

Un oggetto anonimo può dichiarare proprietà proprie oltre ai membri di cui esegue l’override.

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

Oggetto senza supertipo

Se si omette il supertipo, l’oggetto è semplicemente un insieme ad hoc di membri, utile per un raggruppamento locale rapido.

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

Acquisizione delle variabili locali

Gli oggetti anonimi possono acquisire variabili dall’ambito contenitore, a differenza delle classi annidate statiche.

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

Come listener

Un uso comune consiste nel passare un’implementazione inline come callback o listener.

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

Tipo di un oggetto anonimo

Quando viene restituito da una funzione, il tipo inferito è il supertipo dichiarato, oppure Any se non ne esiste alcuno. I membri aggiuntivi sono visibili solo localmente.

interface Named { val name: String }

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

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

Oggetti anonimi o lambda

Per le interfacce con un solo metodo, una lambda è più breve, ma gli oggetti anonimi sono necessari quando occorre eseguire l’override di più membri o conservare uno stato.

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

Espressione object o dichiarazione object

Un’espressione object crea una nuova istanza ogni volta. Una dichiarazione object (object Name {}) è un singleton con nome. Sembrano simili, ma differiscono per durata di vita.

object Singleton { val id = 1 }

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

Un comparatore compatto

Gli oggetti anonimi sono utili per comparatori o strategie usati una sola volta.

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

Verifica rapida

Verifichi la sua comprensione degli oggetti anonimi.

Riepilogo

Ha imparato a conoscere gli oggetti anonimi:

L’espressione object : Type {} crea un’istanza senza nome.
Possono implementare interfacce, estendere classi open e conservare uno stato.
Acquisiscono le variabili locali dell’ambito contenitore.
Li utilizzi per callback con più metodi; preferisca le lambda per i metodi singoli.

interface Run { fun go() }

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

Domande Frequenti

La lezione «Oggetti anonimi» è gratuita?

Sì — il testo completo di «Oggetti anonimi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Oggetti anonimi»?

Implementazioni inline Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Oggetti anonimi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy