object in Kotlin: sintassi e utilizzo pratico degli oggetti singleton

Cos'è object in Kotlin?

object in Kotlin è una forma di dichiarazione speciale che contemporaneamente definisce una classe e crea la sua unica istanza (singleton). È un ibrido tra dichiarazione di classe e creazione di istanza in un'unica costruzione.

In Java, creare un singleton richiede un costruttore privato, un campo statico, un metodo getInstance e la gestione della sicurezza dei thread. Kotlin object fa questo con una singola riga di codice: object MySingleton { }. Il compilatore genera automaticamente un'inizializzazione lazy thread-safe utilizzando il meccanismo static initializer nel bytecode JVM.

Secondo la Specifica del linguaggio Kotlin (2026), object declaration viene compilato in una classe finale con un costruttore privato e un campo statico INSTANCE inizializzato in un blocco statico. Questo garantisce l'atomicità dell'inizializzazione a livello JVM.

Oggetti singleton (object declaration)

Object declaration (oggetto singleton) viene dichiarato usando la parola chiave object seguita da un nome. Il corpo dell'oggetto può contenere proprietà, metodi, blocchi init ed ereditare altre classi o interfacce.

object DatabaseManager {
    private val connection: String = "jdbc:postgresql://localhost:5432/app"
    
    fun query(sql: String): List<Map<String, Any>> {
        // esecuzione della query
        return emptyList()
    }
}

// Utilizzo
DatabaseManager.query("SELECT * FROM users")

L'inizializzazione di DatabaseManager avviene al primo accesso — in modo lazy e thread-safe. Non è richiesto alcun codice di sincronizzazione aggiuntivo.

Ereditarietà per object

Object può ereditare classi e interfacce regolari. Ciò consente di utilizzare object come implementazione di una classe astratta o interfaccia con una singola istanza.

interface Logger {
    fun log(message: String)
}

object ConsoleLogger : Logger {
    override fun log(message: String) {
        println("[LOG] $message")
    }
}

Companion object

companion object è un object speciale dichiarato all'interno di una classe con la parola chiave companion. Sostituisce i membri statici in Kotlin poiché il linguaggio non ha la parola chiave static.

class ApiClient {
    companion object {
        private const val BASE_URL = "https://api.example.com"
        
        fun create(): ApiClient {
            return ApiClient()
        }
    }
}

// Chiamata senza creare un'istanza di ApiClient
val client = ApiClient.create()

Companion object può avere un nome (predefinito Companion), implementare interfacce ed essere esteso tramite extension functions. A differenza dei metodi statici in Java, un companion object è un oggetto completo che può essere passato come argomento o memorizzato in una variabile.

Secondo le Buone pratiche Kotlin (2026), companion object viene utilizzato per metodi factory, costanti e utilità statiche correlate alla classe. Si consiglia di evitare un uso eccessivo di companion object — per utilità non correlate, sono preferibili funzioni di livello superiore.

Annotazione @JvmStatic

Per la compatibilità con Java, i metodi del companion object possono essere annotati con @JvmStatic. Questo genera un vero metodo statico nel bytecode JVM, accessibile dal codice Java senza la sintassi Companion.

Object expressions (oggetti anonimi)

Object expression è un oggetto anonimo creato sul momento per sovrascrivere metodi di una classe o interfaccia senza dichiarare una classe denominata separata.

val handler = object : Runnable {
    override fun run() {
        println("Attività eseguita")
    }
}

thread(handler)

Object expressions differiscono dalle dichiarazioni object perché creano una nuova istanza ogni volta che vengono eseguite. Non sono singleton e non hanno nome. Gli oggetti anonimi possono catturare variabili dalla loro chiusura, proprio come le lambda.

A differenza di Java, dove le classi anonime possono ereditare un solo tipo, l'object expression di Kotlin può ereditare multipli tipi contemporaneamente.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Rendering del pulsante")
    override fun click() = println("Pulsante cliccato")
}

Scenari pratici di utilizzo

Object è una delle costruzioni più versatili di Kotlin, utilizzata in molti scenari.

Singleton di Repository

Nei progetti Android, object viene spesso utilizzato per dichiarare un Repository dove non sono necessarie più istanze. Un'unica istanza garantisce la coerenza dei dati.

object UserRepository {
    fun getUser(id: Int): User? {
        // ottenendo l'utente
        return null
    }
}

Metodi factory tramite companion object

Companion object con metodi factory è un'alternativa a costruttori multipli. I metodi factory nominati rendono il codice auto-documentante.

data class GsonParser {
    companion object {
        fun create(): GsonParser = GsonParser()
        fun createPretty(): GsonParser = GsonParser()
    }
}

Costanti ed enumerazioni

Object può fungere da contenitore per costanti, sostituendo i campi static final in Java. Object supporta l'ereditarietà, consentendo di creare gerarchie di configurazione.

Secondo la Libreria standard Kotlin (2026), object declaration è il modo più performante per creare un singleton in Kotlin, superando le implementazioni double-checked locking e paragonabile al singleton enum in Java.