object sa Kotlin: ano ito, syntax at paggamit ng singleton object

Ano ang object sa Kotlin?

object sa Kotlin — ay isang espesyal na anyo ng deklarasyon na sabay na nagdedefine ng klase at lumilikha ng nag-iisang instance nito (singleton). Ito ay hybrid ng class declaration at instance creation sa iisang konstruksyon.

Sa Java para gumawa ng singleton, kailangan mong sumulat ng pribadong konstruktor, static na field, getInstance method, at pangasiwaan ang thread-safety. Ginagawa ito ng Kotlin object sa isang linya ng code: object MySingleton { }. Awtomatikong bumubuo ang compiler ng thread-safe na tamad na inisyalisasyon gamit ang static initializer mechanism sa JVM bytecode.

Ayon sa Kotlin Language Specification (2026), ang object declaration ay nagko-compile sa isang final class na may pribadong konstruktor at static na field na INSTANCE, na na-initialize sa isang static block. Ginagarantiya nito ang atomicidad ng inisyalisasyon sa antas ng JVM.

Singleton object (object declaration)

Object declaration (singleton object) ay idinedeklara gamit ang keyword na object, na sinusundan ng pangalan. Ang katawan ng object ay maaaring maglaman ng mga property, method, init block, at magmana mula sa ibang mga klase o interface.

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

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

Inisyalisasyon ng DatabaseManager ay nangyayari sa sandali ng unang pag-access — tamad at thread-safe. Walang karagdagang code para sa synchronisasyon ang kinakailangan.

Pamana para sa object

Object ay maaaring magmana mula sa ordinaryong klase at interface. Pinapayagan nito ang paggamit ng object bilang implementasyon ng abstract class o interface na may iisang instance.

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object — ay isang espesyal na object na idinedeklara sa loob ng isang klase gamit ang keyword na companion. Pinapalitan nito ang static na miyembro sa Kotlin, dahil walang static keyword sa wika.

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

// Pagtawag nang hindi lumilikha ng instance ng ApiClient
val client = ApiClient.create()

Companion object ay maaaring magkaroon ng pangalan (default Companion), mag-implement ng mga interface, at mapalawak sa pamamagitan ng extension functions. Hindi tulad ng static na method sa Java, ang companion object ay isang ganap na object na maaaring ipasa bilang argumento o i-store sa isang variable.

Ayon sa Kotlin Best Practices (2026), ang companion object ay ginagamit para sa factory method, constants, at static na utility na nauugnay sa klase. Inirerekomenda na iwasan ang labis na paggamit ng companion object — para sa hindi nauugnay na utility, mas mainam na gumamit ng top-level function.

Annotation na @JvmStatic

Para sa compatibility sa Java, ang mga method ng companion object ay maaaring i-annotate ng @JvmStatic. Bumubuo ito ng tunay na static na method sa JVM bytecode, na accessible mula sa Java code nang walang Companion syntax.

Object expressions (anonymous object)

Object expression — ay isang anonymous object na nilikha on-the-spot para mag-override ng mga method ng klase o interface nang hindi nagdedeklara ng hiwalay na pinangalanang klase.

val handler = object : Runnable {
    override fun run() {
        println("Na-execute ang task")
    }
}

thread(handler)

Object expressions ay naiiba sa object declaration dahil gumagawa sila ng bagong instance sa bawat execution. Hindi sila singleton at walang pangalan. Ang anonymous object ay maaaring kumuha ng mga variable mula sa closure, tulad ng mga lambda.

Hindi tulad sa Java, kung saan ang anonymous class ay maaari lamang magmana ng isang uri, ang Kotlin object expression ay maaaring magmana ng maramihang uri nang sabay-sabay.

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("Pag-render ng button")
    override fun click() = println("Na-click ang button")
}

Mga praktikal na senaryo ng paggamit

Object — isa sa pinaka-versatile na konstruksyon ng Kotlin, ginagamit sa maraming senaryo.

Singleton repository

Sa mga proyekto ng Android, ang object ay kadalasang ginagamit para magdeklara ng Repository, kung saan hindi kailangan ng maraming instance. Ginagarantiya ng iisang instance ang consistency ng data.

object UserRepository {
    fun getUser(id: Int): User? {
        // pagkuha ng user
        return null
    }
}

Factory method sa pamamagitan ng companion object

Companion object na may factory method — alternatibo sa maramihang konstruktor. Ang pinangalanang factory method ay ginagawang self-documenting ang code.

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

Constant at enumeration

Object ay maaaring magsilbi bilang container para sa mga constant, na pinapalitan ang static final field sa Java. Sinusuportahan ng object ang pamana, na nagpapahintulot sa paglikha ng hierarchy ng configuration.

Ayon sa Kotlin Standard Library (2026), ang object declaration ay ang pinaka-performant na paraan ng paggawa ng singleton sa Kotlin, na lumalampas sa "double-checked locking" implementations sa bilis at maihahambing sa enum singleton sa Java.