ออบเจ็กต์นิรนาม
การทำงานที่นำไปใช้แบบอินไลน์
ออบเจ็กต์นิรนาม เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- คลาสซ้อนภายใน
- คลาสภายใน
- ออบเจ็กต์นิรนาม
- คลาสภายในฟังก์ชัน