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

override, final และการป้องกันการสร้างคลาสย่อย

การเขียนทับเมธอดและคุณสมบัติ รวมถึงการปิดผนึกคลาสด้วย final

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

ยินดีต้อนรับ

คีย์เวิร์ด `override` ช่วยให้คลาสย่อยแทนที่การทำงานของคลาสแม่ได้ ส่วน `final` จะป้องกันการแทนที่หรือการสร้างคลาสย่อยเพิ่มเติม เพื่อปกป้องข้อกำหนดของ API ของคุณ

เมธอด override

```swift class Animal { func speak() { print("...") } } class Cat: Animal { override func speak() { print("Meow") } } Cat().speak() // "Meow" ``` `override` เป็นสิ่งที่ต้องระบุ — คอมไพเลอร์จะปฏิเสธการซ่อนชื่อโดยไม่ตั้งใจ

คุณสมบัติ override

```swift class Shape { var area: Double { 0 } } class Square: Shape { var side: Double init(_ s: Double) { side = s } override var area: Double { side * side } } print(Square(4).area) // 16 ```

การเรียก super ในการแทนที่

```swift class Logger { func log(_ msg: String) { print("[LOG] \(msg)") } } class TimedLogger: Logger { override func log(_ msg: String) { print(Date(), terminator: " ") super.log(msg) } } ```

เมธอดและคุณสมบัติ final

ทำเครื่องหมายเมธอดหรือคุณสมบัติด้วย `final` เพื่อป้องกันการแทนที่: ```swift class BankAccount { final func transfer(amount: Double) { ... } // cannot override var balance: Double = 0 } ```

คลาส final

ทำเครื่องหมายคลาสทั้งคลาสด้วย `final` เพื่อป้องกันการสร้างคลาสย่อย: ```swift final class Singleton { static let shared = Singleton() private init() {} } // class Sub: Singleton { } ❌ ``` `final` ยังช่วยให้ปรับการทำงานให้เหมาะสมได้ด้วย — คอมไพเลอร์สามารถเรียกใช้เมธอดแบบคงที่ได้

เหตุใดจึงใช้ final

ประโยชน์ของ `final`: 1. ประสิทธิภาพ: เรียกใช้แบบคงที่แทนการค้นหาในตารางเสมือน 2. ความปลอดภัย: บังคับใช้ข้อกำหนดของ API — คลาสย่อยไม่สามารถทำลายเงื่อนไขคงที่ของคุณได้ 3. เอกสารกำกับ: สื่อว่าคลาสนี้ไม่ได้ออกแบบมาเพื่อการสืบทอด

การแทนที่คุณสมบัติที่คำนวณ

```swift class Vehicle { var description: String { "Vehicle" } } class Tesla: Vehicle { override var description: String { "Tesla - " + super.description } } print(Tesla().description) // "Tesla - Vehicle" ```

การแทนที่ตัวสังเกตคุณสมบัติ

```swift class A { var x = 0 } class B: A { override var x: Int { didSet { print("B.x changed to \(x)") } } } var b = B() b.x = 5 // "B.x changed to 5" ```

การป้องกันการแทนที่โดยไม่ตั้งใจ

หากไม่มี `override` การซ่อนชื่อโดยไม่ตั้งใจจะทำให้เกิดข้อผิดพลาดขณะคอมไพล์: ```swift class Parent { func greet() { } } class Child: Parent { func greet() { } // ❌ must write 'override' } ``` วิธีนี้ช่วยป้องกันข้อผิดพลาดที่ไม่แสดงออก เมื่อ API ของคลาสแม่มีการเปลี่ยนแปลง

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

คีย์เวิร์ดใดป้องกันไม่ให้สร้างคลาสย่อยจากคลาสหนึ่ง

สรุปทบทวน

ประเด็นสำคัญ: • ต้องใช้ `override` เมื่อแทนที่เมธอดหรือคุณสมบัติของคลาสแม่ • `super.method()` เรียกการทำงานของคลาสแม่ • `final func/var` — ป้องกันการแทนที่สมาชิกนั้นโดยเฉพาะ • `final class` — ป้องกันการสร้างคลาสย่อยทั้งหมด • `final` ทำให้เรียกใช้แบบคงที่ได้ — เพิ่มประสิทธิภาพโดยไม่ต้องทำอะไรเพิ่มเติม ถัดไป: การแปลงชนิดด้วย is, as?, as!

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

บทเรียน “override, final และการป้องกันการสร้างคลาสย่อย” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “override, final และการป้องกันการสร้างคลาสย่อย”

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

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

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

บทเรียน “override, final และการป้องกันการสร้างคลาสย่อย” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การสืบทอดคลาสและคีย์เวิร์ด super
  2. override, final และการป้องกันการสร้างคลาสย่อย
  3. การแปลงชนิด: is, as?, as! และ as
  4. ตัวทำลายและวงจรชีวิตหน่วยความจำ
← กลับไปที่ Swift Academy