object ใน Kotlin: ไวยากรณ์และการใช้งานจริงของออบเจ็กต์ซิงเกิลตัน

object ใน Kotlin คืออะไร?

object ใน Kotlin เป็นรูปแบบการประกาศพิเศษที่กำหนดคลาสและสร้างอินสแตนซ์เดียว (ซิงเกิลตัน) พร้อมกัน เป็นการผสมผสานระหว่างการประกาศคลาสและการสร้างอินสแตนซ์ในโครงสร้างเดียว

ใน Java การสร้างซิงเกิลตันต้องใช้คอนสตรัคเตอร์ส่วนตัว ฟิลด์สแตติก เมธอด getInstance และการจัดการความปลอดภัยของเธรด Kotlin object ทำสิ่งนี้ด้วยโค้ดบรรทัดเดียว: object MySingleton { } คอมไพเลอร์จะสร้างการเริ่มต้นแบบขี้เกียจที่ปลอดภัยต่อเธรดโดยอัตโนมัติโดยใช้กลไก static initializer ในไบต์โค้ด JVM

ตาม ข้อกำหนดภาษา Kotlin (2026) การประกาศ object declaration จะถูกคอมไพล์เป็นคลาส final ที่มีคอนสตรัคเตอร์ส่วนตัวและฟิลด์สแตติก INSTANCE ที่เริ่มต้นในบล็อกสแตติก ซึ่งรับประกันความเป็นอะตอมของการเริ่มต้นในระดับ JVM

ออบเจ็กต์ซิงเกิลตัน (object declaration)

Object declaration (ออบเจ็กต์ซิงเกิลตัน) ประกาศโดยใช้คีย์เวิร์ด object ตามด้วยชื่อ ตัวออบเจ็กต์สามารถมีคุณสมบัติ เมธอด บล็อก init และสืบทอดคลาสหรืออินเทอร์เฟซอื่น ๆ

object DatabaseManager {
    private val connection: String = "jdbc:postgresql://localhost:5432/app"
    
    fun query(sql: String): List<Map<String, Any>> {
        // กำลังดำเนินการค้นหา
        return emptyList()
    }
}

// การใช้งาน
DatabaseManager.query("SELECT * FROM users")

การเริ่มต้น DatabaseManager เกิดขึ้นเมื่อมีการเข้าถึงครั้งแรก — แบบขี้เกียจและปลอดภัยต่อเธรด ไม่จำเป็นต้องใช้โค้ดซิงโครไนซ์เพิ่มเติม

การสืบทอดสำหรับ object

Object สามารถสืบทอดคลาสและอินเทอร์เฟซทั่วไป ซึ่งช่วยให้ใช้ object เป็นการ implement คลาสนามธรรมหรืออินเทอร์เฟซที่มีอินสแตนซ์เดียว

interface Logger {
    fun log(message: String)
}

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

Companion object

companion object เป็น object พิเศษที่ประกาศภายในคลาสด้วยคีย์เวิร์ด companion มันแทนที่สมาชิกแบบสแตติกใน Kotlin เนื่องจากภาษาไม่มีคีย์เวิร์ด static

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

// เรียกโดยไม่สร้างอินสแตนซ์ ApiClient
val client = ApiClient.create()

Companion object สามารถมีชื่อ (ค่าเริ่มต้นคือ Companion) implement อินเทอร์เฟซ และถูกขยายผ่าน extension functions แตกต่างจากเมธอดสแตติกใน Java companion object เป็นออบเจ็กต์เต็มรูปแบบที่สามารถส่งเป็นอาร์กิวเมนต์หรือเก็บในตัวแปรได้

ตาม แนวทางปฏิบัติที่ดีที่สุดของ Kotlin (2026) companion object ใช้สำหรับเมธอดโรงงาน ค่าคงที่ และยูทิลิตี้สแตติกที่เกี่ยวข้องกับคลาส ขอแนะนำให้หลีกเลี่ยงการใช้ companion object มากเกินไป — สำหรับยูทิลิตี้ที่ไม่เกี่ยวข้อง ฟังก์ชันระดับบนสุดจะดีกว่า

คำอธิบายประกอบ @JvmStatic

เพื่อความเข้ากันได้กับ Java เมธอดของ companion object สามารถมีคำอธิบายประกอบ @JvmStatic ซึ่งสร้างเมธอดสแตติกจริงในไบต์โค้ด JVM ที่เข้าถึงได้จากโค้ด Java โดยไม่มีไวยากรณ์ Companion

Object expressions (ออบเจ็กต์นิรนาม)

Object expression คือออบเจ็กต์นิรนามที่สร้างขึ้นทันทีเพื่อโอเวอร์ไรด์เมธอดของคลาสหรืออินเทอร์เฟซโดยไม่ต้องประกาศคลาสที่มีชื่อแยกต่างหาก

val handler = object : Runnable {
    override fun run() {
        println("งานถูกดำเนินการแล้ว")
    }
}

thread(handler)

Object expressions แตกต่างจากการประกาศ object ตรงที่สร้างอินสแตนซ์ใหม่ทุกครั้งที่ดำเนินการ พวกมันไม่ใช่ซิงเกิลตันและไม่มีชื่อ ออบเจ็กต์นิรนามสามารถจับตัวแปรจากคลอเจอร์ได้เช่นเดียวกับแลมบ์ดา

แตกต่างจาก Java ที่คลาสนิรนามสามารถสืบทอดได้เพียงประเภทเดียว object expression ของ Kotlin สามารถสืบทอด หลาย ประเภทพร้อมกัน

interface Clickable {
    fun click()
}

abstract class View {
    abstract fun render()
}

val button = object : View(), Clickable {
    override fun render() = println("กำลังเรนเดอร์ปุ่ม")
    override fun click() = println("คลิกปุ่มแล้ว")
}

สถานการณ์การใช้งานจริง

Object เป็นหนึ่งในโครงสร้างที่หลากหลายที่สุดของ Kotlin ใช้ในหลายสถานการณ์

ซิงเกิลตัน Repository

ในโปรเจกต์ Android object มักใช้ในการประกาศ Repository ที่ไม่ต้องการหลายอินสแตนซ์ อินสแตนซ์เดียวรับประกันความสอดคล้องของข้อมูล

object UserRepository {
    fun getUser(id: Int): User? {
        // กำลังรับผู้ใช้
        return null
    }
}

เมธอดโรงงานผ่าน companion object

Companion object กับเมธอดโรงงานเป็นทางเลือกแทนคอนสตรัคเตอร์หลายตัว เมธอดโรงงานที่มีชื่อทำให้โค้ดอธิบายตนเองได้

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

ค่าคงที่และการแจงนับ

Object สามารถทำหน้าที่เป็นคอนเทนเนอร์สำหรับค่าคงที่ แทนที่ฟิลด์ static final ใน Java Object รองรับการสืบทอด ซึ่งช่วยให้สร้างลำดับชั้นการกำหนดค่าได้

ตาม ไลบรารีมาตรฐาน Kotlin (2026) การประกาศ object declaration เป็นวิธีที่มีประสิทธิภาพที่สุดในการสร้างซิงเกิลตันใน Kotlin เหนือกว่าการ implement แบบ double-checked locking และเทียบได้กับซิงเกิลตัน enum ใน Java