0Pricing
Kotlin Academy · บทเรียน

ออบเจ็กต์นิรนาม

การทำงานที่นำไปใช้แบบอินไลน์

ออบเจ็กต์นิรนาม เป็นบทเรียน Kotlin Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Kotlin Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

การใช้งานแบบฝังในบรรทัด

ออบเจ็กต์นิรนาม จะสร้างอินสแตนซ์ของคลาสหรืออินเทอร์เฟซโดยไม่ต้องตั้งชื่อคลาสใหม่ ให้ใช้นิพจน์ object

interface Greeter { fun greet(): String }

fun main() {
    val g = object : Greeter {
        override fun greet() = "Hi"
    }
    println(g.greet())
}

การใช้งานอินเทอร์เฟซ

นิพจน์ออบเจ็กต์สามารถใช้งานอินเทอร์เฟซได้หนึ่งรายการหรือมากกว่านั้น ณ จุดที่จำเป็นต้องใช้

interface Clickable { fun click() }

fun main() {
    val button = object : Clickable {
        override fun click() = println("Clicked")
    }
    button.click()
}

การเขียนทับสมาชิกของคลาส

คุณสามารถสร้างคลาสลูกแบบนิรนามจากคลาสเปิดให้สืบทอด และเขียนทับสมาชิกของคลาสนั้นได้

open class Animal { open fun sound() = "..." }

fun main() {
    val cat = object : Animal() {
        override fun sound() = "Meow"
    }
    println(cat.sound())
}

การเก็บสถานะเพิ่มเติม

ออบเจ็กต์นิรนามอาจประกาศพร็อพเพอร์ตีของตนเองเพิ่มเติมจากสมาชิกที่เขียนทับได้

fun main() {
    val point = object {
        val x = 3
        val y = 4
    }
    println("${point.x}, ${point.y}")
}

ออบเจ็กต์ที่ไม่มีชนิดแม่

หากไม่ระบุชนิดแม่ ออบเจ็กต์จะเป็นเพียงกลุ่มสมาชิกเฉพาะกิจ ซึ่งมีประโยชน์สำหรับการจัดกลุ่มภายในอย่างรวดเร็ว

fun main() {
    val config = object {
        val retries = 3
        val timeout = 30
    }
    println(config.retries)
}

การจับตัวแปรท้องถิ่น

ออบเจ็กต์นิรนามสามารถจับตัวแปรจากขอบเขตที่ครอบคลุมอยู่ได้ ต่างจากคลาส Nested แบบคงที่

fun makeCounter(start: Int): () -> Int {
    var count = start
    val obj = object {
        fun next() = count++
    }
    return { obj.next() }
}

fun main() {
    val c = makeCounter(10)
    println(c())
    println(c())
}

การใช้เป็นผู้รับฟัง

การใช้งานทั่วไปคือส่งการใช้งานแบบฝังในบรรทัดไปเป็นฟังก์ชันเรียกกลับหรือผู้รับฟัง

interface OnDone { fun done(result: Int) }

fun compute(cb: OnDone) {
    cb.done(42)
}

fun main() {
    compute(object : OnDone {
        override fun done(result: Int) = println("Got $result")
    })
}

ชนิดของออบเจ็กต์นิรนาม

เมื่อส่งคืนจากฟังก์ชัน ชนิดข้อมูลที่อนุมานได้จะเป็นชนิดแม่ที่ประกาศไว้ หรือเป็นชนิดใดก็ได้หากไม่ได้ประกาศชนิดแม่ สมาชิกเพิ่มเติมจะมองเห็นได้เฉพาะภายในเท่านั้น

interface Named { val name: String }

fun make(): Named = object : Named {
    override val name = "X"
}

fun main() {
    println(make().name)
}

ออบเจ็กต์นิรนามเทียบกับแลมบ์ดา

สำหรับอินเทอร์เฟซที่มีเมธอดเดียว แลมบ์ดาจะเขียนได้สั้นกว่า แต่ออบเจ็กต์นิรนามจำเป็นเมื่อคุณต้องเขียนทับสมาชิก หลายรายการ หรือเก็บสถานะ

interface Handler {
    fun onStart()
    fun onStop()
}

fun main() {
    val h = object : Handler {
        override fun onStart() = println("start")
        override fun onStop() = println("stop")
    }
    h.onStart()
    h.onStop()
}

นิพจน์ออบเจ็กต์เทียบกับการประกาศออบเจ็กต์

นิพจน์ออบเจ็กต์จะสร้างอินสแตนซ์ใหม่ทุกครั้ง ส่วนการประกาศออบเจ็กต์ (object Name {}) จะเป็นซิงเกิลตันที่มีชื่อ ทั้งสองรูปแบบดูคล้ายกัน แต่มีอายุการใช้งานแตกต่างกัน

object Singleton { val id = 1 }

fun main() {
    val fresh = object { val id = 2 }
    println(Singleton.id)
    println(fresh.id)
}

ตัวเปรียบเทียบแบบกระชับ

ออบเจ็กต์นิรนามเหมาะสำหรับตัวเปรียบเทียบหรือกลยุทธ์ที่ใช้เฉพาะครั้ง

fun main() {
    val cmp = object : Comparator<Int> {
        override fun compare(a: Int, b: Int) = b - a
    }
    val list = listOf(1, 3, 2).sortedWith(cmp)
    println(list)
}

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจเกี่ยวกับออบเจ็กต์นิรนามของคุณ

สรุปทบทวน

คุณได้เรียนรู้เกี่ยวกับ ออบเจ็กต์นิรนาม:

  • นิพจน์ object : Type {} จะสร้างอินสแตนซ์ที่ไม่มีชื่อ
  • สามารถใช้งานอินเทอร์เฟซ สืบทอดจากคลาสที่เปิดให้สืบทอด และเก็บสถานะได้
  • สามารถจับตัวแปรท้องถิ่นจากขอบเขตที่ครอบคลุมอยู่ได้
  • ใช้สำหรับฟังก์ชันเรียกกลับที่มีหลายเมธอด และเลือกใช้แลมบ์ดาสำหรับกรณีที่มีเมธอดเดียว
interface Run { fun go() }

fun main() {
    val r = object : Run { override fun go() = println("go") }
    r.go()
}

คำถามที่พบบ่อย

บทเรียน “ออบเจ็กต์นิรนาม” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ออบเจ็กต์นิรนาม” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Kotlin Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ออบเจ็กต์นิรนาม”

การทำงานที่นำไปใช้แบบอินไลน์ คุณปฏิบัติ Kotlin Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Kotlin Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Kotlin Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “ออบเจ็กต์นิรนาม” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Kotlin Academy นี้ได้ไหม

ได้ บทเรียน Kotlin Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. คลาสซ้อนภายใน
  2. คลาสภายใน
  3. ออบเจ็กต์นิรนาม
  4. คลาสภายในฟังก์ชัน
← กลับไปที่ Kotlin Academy