object in Kotlin: wat het is, syntaxis en toepassing van singleton-objecten

Wat is object in Kotlin?

object in Kotlin — is een speciale declaratievorm die tegelijkertijd een klasse definieert en de enige instantie ervan (singleton) creëert. Het is een hybride van class declaration en instance creation in één constructie.

In Java moet je voor het maken van een singleton een private constructor, een statisch veld, een getInstance-methode schrijven en draadveiligheid afhandelen. Kotlin object doet dit met één regel code: object MySingleton { }. De compiler genereert automatisch draadveilige luie initialisatie met behulp van het static initializer-mechanisme in JVM-bytecode.

Volgens Kotlin Language Specification (2026) wordt object declaration gecompileerd tot een final klasse met een private constructor en een statisch veld INSTANCE, geïnitialiseerd in een statisch blok. Dit garandeert atomiciteit van initialisatie op JVM-niveau.

Singleton-objecten (object declaration)

Object declaration (singleton-object) wordt gedeclareerd met het sleutelwoord object, gevolgd door een naam. Het lichaam van het object kan eigenschappen, methoden, init-blokken bevatten en andere klassen of interfaces erven.

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

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

Initialisatie van DatabaseManager vindt plaats op het moment van eerste toegang — lui en draadveilig. Er is geen extra code voor synchronisatie nodig.

Overerving voor object

Object kan gewone klassen en interfaces erven. Dit maakt het mogelijk om object te gebruiken als implementatie van een abstracte klasse of interface met één enkele instantie.

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object — is een speciaal object dat binnen een klasse wordt gedeclareerd met het sleutelwoord companion. Het vervangt statische leden in Kotlin, omdat de taal geen static sleutelwoord heeft.

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

// Aanroepen zonder een ApiClient-instantie te maken
val client = ApiClient.create()

Companion object kan een naam hebben (standaard Companion), interfaces implementeren en worden uitgebreid via extension functions. In tegenstelling tot statische methoden in Java is companion object een volwaardig object dat als argument kan worden doorgegeven of in een variabele kan worden opgeslagen.

Volgens Kotlin Best Practices (2026) wordt companion object gebruikt voor factory-methoden, constanten en statische hulpprogramma's die aan een klasse zijn gekoppeld. Het wordt aanbevolen overmatig gebruik van companion object te vermijden — voor niet-gerelateerde hulpprogramma's kunt u beter functies op het hoogste niveau gebruiken.

@JvmStatic-annotatie

Voor compatibiliteit met Java kunnen companion object-methoden worden geannoteerd met @JvmStatic. Dit genereert een echte statische methode in JVM-bytecode, toegankelijk vanuit Java-code zonder Companion-syntaxis.

Object expressions (anonieme objecten)

Object expression — is een anoniem object dat ter plaatse wordt gemaakt om methoden van een klasse of interface te overschrijven zonder een aparte benoemde klasse te declareren.

val handler = object : Runnable {
    override fun run() {
        println("Taak uitgevoerd")
    }
}

thread(handler)

Object expressions verschillen van object-declaraties doordat ze bij elke uitvoering een nieuwe instantie maken. Het zijn geen singletons en ze hebben geen naam. Anonieme objecten kunnen variabelen uit een closure vastleggen, net als lambda's.

In tegenstelling tot Java, waar anonieme klassen slechts één type kunnen erven, kan Kotlin object expression meerdere typen tegelijk erven.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Knop renderen")
    override fun click() = println("Knop geklikt")
}

Praktische gebruiksscenario's

Object — een van de meest veelzijdige constructies van Kotlin, gebruikt in talloze scenario's.

Singleton-repositories

In Android-projecten wordt object vaak gebruikt voor het declareren van Repository, waar geen meerdere instanties nodig zijn. Een enkele instantie garandeert gegevensconsistentie.

object UserRepository {
    fun getUser(id: Int): User? {
        // ophalen van de gebruiker
        return null
    }
}

Factory-methoden via companion object

Companion object met factory-methoden — een alternatief voor meerdere constructors. Benoemde factory-methoden maken code zelfdocumenterend.

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

Constanten en opsommingen

Object kan dienen als container voor constanten, ter vervanging van statische final-velden in Java. Object ondersteunt overerving, waardoor hiërarchieën van configuraties kunnen worden gemaakt.

Volgens Kotlin Standard Library (2026) is object declaration de meest performante manier om een singleton in Kotlin te maken, sneller dan "double-checked locking"-implementaties en vergelijkbaar met enum singleton in Java.