object i Kotlin: vad det är, syntax och tillämpning av singleton-objekt

Vad är object i Kotlin?

object i Kotlin — är en speciell deklarationsform som samtidigt definierar en klass och skapar dess enda instans (singleton). Det är en hybrid av class declaration och instance creation i en konstruktion.

I Java krävs för att skapa en singleton en privat konstruktor, ett statiskt fält, en getInstance-metod och hantering av trådsäkerhet. Kotlin object gör detta med en kodrad: object MySingleton { }. Kompilatorn genererar automatiskt trådsäker lat initialisering med hjälp av mekanismen static initializer i JVM-bytecode.

Enligt Kotlin Language Specification (2026) kompileras object declaration till en final klass med en privat konstruktor och ett statiskt fält INSTANCE, initierat i ett statiskt block. Detta garanterar atomicitet av initialisering på JVM-nivå.

Singleton-objekt (object declaration)

Object declaration (singleton-objekt) deklareras med nyckelordet object, följt av ett namn. Objektets kropp kan innehålla egenskaper, metoder, init-block och ärva från andra klasser eller gränssnitt.

object DatabaseManager {
    private val connection: String = "jdbc:postgresql://localhost:5432/app"
    
    fun query(sql: String): List<Map<String, Any>> {
        // utföra frågan
        return emptyList()
    }
}

// Användning
DatabaseManager.query("SELECT * FROM users")

Initiering av DatabaseManager sker vid första åtkomst — lat och trådsäker. Ingen extra kod för synkronisering krävs.

Arv för object

Object kan ärva vanliga klasser och gränssnitt. Detta gör det möjligt att använda object som implementering av en abstrakt klass eller ett gränssnitt med en enda instans.

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object — är ett speciellt object deklarerat inuti en klass med nyckelordet companion. Det ersätter statiska medlemmar i Kotlin, eftersom språket inte har något static keyword.

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

// Anropa utan att skapa en ApiClient-instans
val client = ApiClient.create()

Companion object kan ha ett namn (standard Companion), implementera gränssnitt och utökas via extension functions. Till skillnad från statiska metoder i Java är companion object ett fullvärdigt objekt som kan skickas som argument eller lagras i en variabel.

Enligt Kotlin Best Practices (2026) används companion object för fabriksmetoder, konstanter och statiska verktyg kopplade till en klass. Det rekommenderas att undvika överdriven användning av companion object — för orelaterade verktyg är det bättre att använda toppnivåfunktioner.

@JvmStatic-annotering

För kompatibilitet med Java kan metoder i companion object annoteras med @JvmStatic. Detta genererar en riktig statisk metod i JVM-bytecode, tillgänglig från Java-kod utan Companion-syntax.

Object expressions (anonyma objekt)

Object expression — är ett anonymt objekt som skapas på plats för att åsidosätta metoder i en klass eller ett gränssnitt utan att deklarera en separat namngiven klass.

val handler = object : Runnable {
    override fun run() {
        println("Uppgift utförd")
    }
}

thread(handler)

Object expressions skiljer sig från object-deklarationer genom att de skapar en ny instans vid varje exekvering. De är inte singletons och har inget namn. Anonyma objekt kan fånga variabler från en closure, precis som lambdas.

Till skillnad från Java, där anonyma klasser endast kan ärva en typ, kan Kotlin object expression ärva flera typer samtidigt.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Rendering av knapp")
    override fun click() = println("Knapp klickad")
}

Praktiska användningsscenarier

Object — en av de mest mångsidiga konstruktionerna i Kotlin, som används i många scenarier.

Singleton-repositories

I Android-projekt används object ofta för att deklarera Repository, där flera instanser inte behövs. En enda instans garanterar datakonsistens.

object UserRepository {
    fun getUser(id: Int): User? {
        // hämta användaren
        return null
    }
}

Fabriksmetoder via companion object

Companion object med fabriksmetoder — ett alternativ till flera konstruktorer. Namngivna fabriksmetoder gör koden självdokumenterande.

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

Konstanter och uppräkningar

Object kan fungera som en behållare för konstanter, och ersätta statiska final-fält i Java. Object stöder arv, vilket möjliggör skapande av konfigurationshierarkier.

Enligt Kotlin Standard Library (2026) är object declaration det mest prestandaeffektiva sättet att skapa en singleton i Kotlin, snabbare än "double-checked locking"-implementeringar och jämförbart med enum singleton i Java.