object a Kotlinban: mi ez, szintaxis és singleton objektumok alkalmazása

Mi az object a Kotlinban?

object a Kotlinban — egy speciális deklarációs forma, amely egyszerre definiál egy osztályt és létrehozza annak egyetlen példányát (singleton). Ez a class declaration és instance creation hibridje egyetlen konstrukcióban.

Java-ban egy singleton létrehozásához privát konstruktort, statikus mezőt, getInstance metódust kell írni, és kezelni kell a szálbiztonságot. A Kotlin object ezt egyetlen kódsorral teszi: object MySingleton { }. A fordító automatikusan szálbiztos lusta inicializálást generál a static initializer mechanizmus használatával a JVM bájtkódban.

A Kotlin Language Specification (2026) szerint az object declaration egy final osztállyá fordul, privát konstruktorral és INSTANCE statikus mezővel, amely egy statikus blokkban inicializálódik. Ez garantálja az inicializálás atomosságát JVM szinten.

Singleton objektumok (object declaration)

Object declaration (singleton objektum) az object kulcsszóval deklarálható, amelyet egy név követ. Az objektum törzse tartalmazhat tulajdonságokat, metódusokat, init blokkokat, és örökölhet más osztályoktól vagy interfészektől.

object DatabaseManager {
    private val connection: String = "jdbc:postgresql://localhost:5432/app"
    
    fun query(sql: String): List<Map<String, Any>> {
        // lekérdezés végrehajtása
        return emptyList()
    }
}

// Használat
DatabaseManager.query("SELECT * FROM users")

A DatabaseManager inicializálása az első hozzáférés pillanatában történik — lustán és szálbiztosan. Nincs szükség további kódra a szinkronizációhoz.

Öröklés object számára

Object örökölhet szokásos osztályoktól és interfészektől. Ez lehetővé teszi az object használatát absztrakt osztály vagy interfész egyetlen példánnyal rendelkező implementációjaként.

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object — egy speciális object, amely egy osztályon belül kerül deklarálásra a companion kulcsszóval. Ez helyettesíti a statikus tagokat Kotlinban, mivel a nyelvben nincs static kulcsszó.

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

// Hívás ApiClient példány létrehozása nélkül
val client = ApiClient.create()

Companion object rendelkezhet névvel (alapértelmezetten Companion), implementálhat interfészeket, és bővíthető extension functions segítségével. Ellentétben a Java statikus metódusaival, a companion object egy teljes értékű objektum, amely argumentumként átadható vagy változóban tárolható.

A Kotlin Best Practices (2026) szerint a companion object gyártó metódusokhoz, konstansokhoz és az osztályhoz kapcsolódó statikus segédprogramokhoz használatos. Javasolt elkerülni a companion object túlzott használatát — nem kapcsolódó segédprogramokhoz jobb a legfelső szintű függvényeket használni.

@JvmStatic annotáció

A Java kompatibilitás érdekében a companion object metódusai @JvmStatic annotációval láthatók el. Ez valódi statikus metódust generál a JVM bájtkódban, amely Java kódból Companion szintaxis nélkül érhető el.

Object expressions (anonim objektumok)

Object expression — egy anonim objektum, amely a helyszínen jön létre egy osztály vagy interfész metódusainak felülírására anélkül, hogy külön elnevezett osztályt deklarálnánk.

val handler = object : Runnable {
    override fun run() {
        println("Feladat végrehajtva")
    }
}

thread(handler)

Object expressions abban különböznek az object deklarációktól, hogy minden végrehajtáskor új példányt hoznak létre. Nem singletonok és nincs nevük. Az anonim objektumok változókat foghatnak be a closure-ből, akárcsak a lambdák.

Ellentétben Java-val, ahol az anonim osztályok csak egy típust örökölhetnek, a Kotlin object expression több típust is örökölhet egyszerre.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Gomb renderelése")
    override fun click() = println("Gombra kattintva")
}

Gyakorlati használati forgatókönyvek

Object — a Kotlin egyik legsokoldalúbb konstrukciója, számos forgatókönyvben használatos.

Singleton repository-k

Android projektekben az object gyakran használatos Repository deklarálására, ahol nincs szükség több példányra. Az egyetlen példány garantálja az adatok konzisztenciáját.

object UserRepository {
    fun getUser(id: Int): User? {
        // felhasználó lekérése
        return null
    }
}

Gyártó metódusok companion object segítségével

Companion object gyártó metódusokkal — alternatíva a több konstruktorral szemben. A névvel ellátott gyártó metódusok öndokumentálóvá teszik a kódot.

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

Konstansok és felsorolások

Object szolgálhat konstansok tárolójaként, helyettesítve a Java static final mezőit. Az object támogatja az öröklést, ami lehetővé teszi konfigurációs hierarchiák létrehozását.

A Kotlin Standard Library (2026) szerint az object declaration a legteljesítményesebb módja a singleton létrehozásának Kotlinban, sebességben felülmúlva a "double-checked locking" implementációkat és összehasonlítható a Java enum singleton-jával.