Kotlin เป็นภาษาโปรแกรมสมัยใหม่ที่ใช้ในการพัฒนาแอปพลิเคชัน Android และแอปพลิเคชันฝั่งเซิร์ฟเวอร์ หนึ่งในคุณสมบัติที่น่าสนใจของ Kotlin คือการรองรับคลาสที่ซ้อนกันและคลาสภายใน ในบทความนี้ เราจะพิจารณาอย่างใกล้ชิดเกี่ยวกับคลาสซ้อนและคลาสภายในใน Kotlin และดูว่าสามารถใช้เพื่อปรับปรุงองค์กรและโครงสร้างของโค้ดของคุณได้อย่างไร

คลาสที่ซ้อนกัน

คลาสที่ซ้อนกันคือคลาสที่กำหนดภายในคลาสอื่น ใน Kotlin คุณสามารถกำหนดคลาสที่ซ้อนกันได้โดยการประกาศภายในคลาสภายนอกโดยใช้classคีย์เวิร์ด นี่คือตัวอย่าง:

class Outer {
    class Nested {
        fun `sayHello`() {
            println("Hello from Nested!")
        }
    }
}

คุณสามารถสร้างอินสแตนซ์ของคลาสที่ซ้อนกันโดยใช้ไวยากรณ์:

val nested = Outer.Nested()
nested.`sayHello`() // Output: Hello from Nested!

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

ชั้นเรียนภายใน

คลาสภายในคือคลาสที่ซ้อนกันซึ่งสามารถเข้าถึงสมาชิกของคลาสภายนอกได้ ใน Kotlin คุณสามารถกำหนดคลาสภายในได้โดยใช้innerคีย์เวิร์ดก่อนclassคีย์เวิร์ด นี่คือตัวอย่าง:

class Outer {
    private val name: String = "Outer"
    
    inner class Inner {
        fun `sayHello`() {
            println("Hello from $name.Inner!")
        }
    }
}

คุณสามารถสร้างอินสแตนซ์ของคลาสภายในโดยใช้ไวยากรณ์:

val outer = Outer()
val inner = outer.Inner()
inner.`sayHello`() // Output: Hello from Outer.Inner!

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

ความแตกต่างระหว่างคลาสซ้อนและคลาสภายใน

ข้อแตกต่างที่เห็นได้ชัดบางประการดังนี้

1. การเข้าถึงสมาชิกคลาสภายนอก:คลาสที่ซ้อนกันไม่สามารถเข้าถึงสมาชิกของคลาสภายนอกได้ ในขณะที่คลาสภายในทำได้ คลาสภายในมีการอ้างอิงถึงอินสแตนซ์ของคลาสภายนอก ซึ่งอนุญาตให้เข้าถึงคุณสมบัติและฟังก์ชันได้
2. ขอบเขต:ขอบเขตของคลาสที่ซ้อนกันจะจำกัดเฉพาะคลาสที่ปิดล้อม ในขณะที่ขอบเขตของคลาสภายในจะจำกัดเฉพาะอินสแตนซ์ของคลาสที่ปิดล้อม ซึ่งหมายความว่าคลาสภายในสามารถเข้าถึงสมาชิกส่วนตัวของอินสแตนซ์คลาสภายนอกได้
3. การเริ่มต้น:สามารถสร้างอินสแตนซ์ของคลาสที่ซ้อนกันได้โดยไม่ต้องมีอินสแตนซ์ของคลาสภายนอก ในขณะที่อินสแตนซ์ของคลาสภายในต้องสร้างด้วยอินสแตนซ์ของคลาสภายนอก
4. การใช้งาน:โดยทั่วไปจะใช้คลาสที่ซ้อนกันเพื่อจัดกลุ่มการทำงานที่เกี่ยวข้องกัน ในขณะที่คลาสภายในจะใช้เมื่อคุณต้องการเข้าถึงสมาชิกของคลาสภายนอกจากภายในคลาสที่ซ้อนกัน
5. ไวยากรณ์:ไวยากรณ์สำหรับการประกาศคลาสที่ซ้อนกันเป็นเพียงการประกาศภายในคลาสภายนอกโดยใช้classคำหลัก ไวยากรณ์สำหรับการประกาศคลาสภายในคือการใช้innerคำหลักก่อนclassคำหลัก
6. การตั้งชื่อ:คลาสที่ซ้อนกันจะถูกตั้งชื่อด้วยชื่อของคลาสภายนอกตามด้วยจุดและชื่อของคลาสที่ซ้อนกัน คลาสภายในถูกตั้งชื่อด้วยชื่อของคลาสภายนอกตามด้วยจุดและชื่อของคลาสภายใน และเชื่อมโยงกับอินสแตนซ์ของคลาสภายนอก

บทสรุป

คลาสที่ซ้อนกันและคลาสภายในเป็นคุณสมบัติอันทรงพลังของ Kotlin ที่สามารถช่วยคุณจัดระเบียบและจัดโครงสร้างโค้ดของคุณได้ การจัดกลุ่มฟังก์ชันที่เกี่ยวข้องเข้าด้วยกัน ทำให้โค้ดของคุณเป็นระเบียบมากขึ้นและดูแลรักษาได้ง่ายขึ้น และด้วยการใช้คลาสภายใน คุณสามารถให้คลาสเหล่านั้นเข้าถึงสมาชิกของคลาสภายนอกได้ ซึ่งจะเป็นประโยชน์ในบางสถานการณ์ ครั้งต่อไปคุณ