object în Kotlin: ce este, sintaxa și aplicarea obiectelor singleton

Ce este object în Kotlin?

object în Kotlin — este o formă specială de declarație care definește simultan o clasă și creează singura sa instanță (singleton). Este un hibrid între class declaration și instance creation într-o singură construcție.

În Java pentru a crea un singleton trebuie să scrieți un constructor privat, un câmp static, o metodă getInstance și să gestionați siguranța firelor. Kotlin object face acest lucru cu o singură linie de cod: object MySingleton { }. Compilatorul generează automat inițializarea leneșă thread-safe folosind mecanismul static initializer în bytecode-ul JVM.

Conform Kotlin Language Specification (2026), object declaration se compilează într-o clasă finală cu constructor privat și câmp static INSTANCE, inițializat într-un bloc static. Aceasta garantează atomicitatea inițializării la nivelul JVM.

Obiecte singleton (object declaration)

Object declaration (obiect singleton) se declară folosind cuvântul cheie object, urmat de nume. Corpul obiectului poate conține proprietăți, metode, blocuri init și poate moșteni alte clase sau interfețe.

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

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

Inițializarea DatabaseManager are loc în momentul primei accesări — leneș și thread-safe. Nu este necesar niciun cod suplimentar pentru sincronizare.

Moștenirea pentru object

Object poate moșteni clase obișnuite și interfețe. Acest lucru permite utilizarea object ca implementare a unei clase abstracte sau a unei interfețe cu o singură instanță.

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object — este un object special declarat în interiorul unei clase cu cuvântul cheie companion. Acesta înlocuiește membrii statici în Kotlin, deoarece în limbă nu există cuvântul cheie static.

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

// Apel fără a crea o instanță ApiClient
val client = ApiClient.create()

Companion object poate avea un nume (implicit Companion), poate implementa interfețe și poate fi extins prin extension functions. Spre deosebire de metodele statice din Java, companion object este un obiect complet, care poate fi transmis ca argument sau stocat într-o variabilă.

Conform Kotlin Best Practices (2026), companion object este folosit pentru metode fabrică, constante și utilitare statice asociate clasei. Se recomandă evitarea utilizării excesive a companion object — pentru utilitare neasociate este mai bine să folosiți funcții de nivel superior.

Adnotarea @JvmStatic

Pentru compatibilitatea cu Java, metodele companion object pot fi adnotate cu @JvmStatic. Acest lucru generează o metodă statică reală în bytecode-ul JVM, accesibilă din codul Java fără sintaxa Companion.

Object expressions (obiecte anonime)

Object expression — este un obiect anonim creat pe loc pentru a suprascrie metodele unei clase sau interfețe fără a declara o clasă numită separată.

val handler = object : Runnable {
    override fun run() {
        println("Sarcină executată")
    }
}

thread(handler)

Object expressions diferă de declarațiile object prin faptul că creează o nouă instanță la fiecare execuție. Ele nu sunt singleton și nu au nume. Obiectele anonime pot captura variabile din închidere, la fel ca și lambdele.

Spre deosebire de Java, unde clasele anonime pot moșteni doar un singur tip, Kotlin object expression poate moșteni mai multe tipuri simultan.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Randare buton")
    override fun click() = println("Buton apăsat")
}

Scenarii practice de utilizare

Object — una dintre cele mai versatile construcții din Kotlin, folosită în numeroase scenarii.

Repository-uri singleton

În proiectele Android, object este adesea folosit pentru a declara Repository, unde nu sunt necesare mai multe instanțe. O singură instanță garantează consistența datelor.

object UserRepository {
    fun getUser(id: Int): User? {
        // obținerea utilizatorului
        return null
    }
}

Metode fabrică prin companion object

Companion object cu metode fabrică — o alternativă la constructorii multipli. Metodele fabrică denumite fac codul auto-documentat.

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

Constante și enumerări

Object poate servi ca container pentru constante, înlocuind câmpurile static final din Java. În același timp, object suportă moștenirea, permițând crearea de ierarhii de configurații.

Conform Kotlin Standard Library (2026), object declaration este cel mai performant mod de a crea un singleton în Kotlin, depășind ca viteză implementările „double-checked locking” și fiind comparabil cu enum singleton din Java.