inheritance และ polymorphism ทำงานอย่างไร?

Question

Accepted Answer

**inheritance** ให้ class สืบทอดจาก base class โดยนำสมาชิกมาใช้ซ้ำและขยายความสามารถ ส่วน **polymorphism** ให้คุณจัดการ object ที่สืบทอดผ่านชนิดฐาน โดย method ที่ override ถูกต้องจะถูกเรียกในตอน runtime (ผ่าน `virtual`/`override`) ทั้งสองเป็นกลไก OOP หลักใน C#

## inheritance

```csharp
public class Animal
{
    public string Name { get; set; }
    public virtual string MakeSound() => "some sound";   // virtual — can be overridden
}

public class Dog : Animal     // Dog inherits from Animal (single inheritance)
{
    public override string MakeSound() => "Woof";        // OVERRIDE the base method
    public void Fetch() => Console.WriteLine("fetching");
}

var dog = new Dog { Name = "Rex" };
dog.Name;          // inherited from Animal
dog.MakeSound();    // "Woof"
```

class ที่สืบทอด (`Dog : Animal`) สืบทอดสมาชิกของฐานและสามารถเพิ่มของตัวเองได้ C# รองรับ **single inheritance** (base class เดียว) ส่วน `base.Method()` เรียกการ implement ของฐาน

## polymorphism — virtual / override

```csharp
// treat different derived types through the base type; the ACTUAL type's method runs
List<Animal> animals = new() { new Dog(), new Cat() };
foreach (Animal a in animals)
    Console.WriteLine(a.MakeSound());   // "Woof", "Meow" — runtime dispatch
```

**polymorphism**: method ที่เป็น `virtual` ซึ่งถูก override ใน class ที่สืบทอด จะถูก dispatch ในตอน **runtime** ตามชนิดจริงของ object — ดังนั้นการเรียกเดียวกัน (`a.MakeSound()`) ทำสิ่งต่าง ๆ ตามแต่ละชนิด สิ่งนี้ช่วยให้โค้ดยืดหยุ่นและขยายได้ (จัดการหลายชนิดได้อย่างเป็นแบบเดียวกัน)

## abstract class และ sealed

```csharp
public abstract class Shape
{
    public abstract double Area();        // abstract — derived MUST implement, no body
    public string Describe() => $"Area: {Area()}";   // concrete shared method
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
// var s = new Shape();   // ❌ can't instantiate an abstract class

public sealed class Final { }   // sealed — cannot be inherited from
```

**abstract class** กำหนดฐานบางส่วน (มี abstract method ที่ subclass ต้อง implement พร้อมโค้ดที่ใช้ร่วมกัน) ส่วน `sealed` ป้องกันการสืบทอดต่อ

## ทำไมจึงสำคัญ

inheritance และ polymorphism เป็นกลไก OOP หลักใน C# พื้นฐานต่อการออกแบบเชิงวัตถุและการทำงานกับเฟรมเวิร์ก .NET (ซึ่งใช้สิ่งเหล่านี้อย่างกว้างขวาง) ดังนั้นการเข้าใจจึงจำเป็น **inheritance** ให้การนำโค้ดมาใช้ซ้ำผ่านความสัมพันธ์แบบ "is-a" (Dog เป็น Animal) แม้ว่า C# จะอนุญาตเพียง single inheritance ส่วน **polymorphism** — ผ่าน `virtual`/`override` และการ dispatch method ในตอน runtime — สำคัญเป็นพิเศษ: มันให้คุณจัดการชนิดที่สืบทอดต่าง ๆ อย่างเป็นแบบเดียวกันผ่านชนิดฐาน ในขณะที่พฤติกรรมเฉพาะชนิดที่ถูกต้องทำงานโดยอัตโนมัติ ช่วยให้การออกแบบยืดหยุ่นและขยายได้ (ประมวลผลคอลเล็กชันของรูปทรงต่าง ๆ ที่แต่ละตัวคำนวณพื้นที่ของตนเอง)

การเข้าใจกลไก `virtual`/`override` (ฐานทำเครื่องหมาย method ว่า override ได้ class ที่สืบทอด override มัน และ runtime dispatch ไปยังเวอร์ชันของชนิดจริง), **abstract class** (ฐานบางส่วนที่มี method ที่ subclass ต้อง implement พร้อมโค้ดที่ใช้ร่วมกัน) และ `sealed` (ป้องกันการสืบทอด) เป็นสิ่งจำเป็นในการออกแบบลำดับชั้นของ class และการเข้าใจว่าเฟรมเวิร์กและไลบรารี .NET ถูกจัดโครงสร้างอย่างไร

เนื่องจาก inheritance และ polymorphism เป็นรากฐานของ C# เชิงวัตถุและตัวเฟรมเวิร์กเอง และเนื่องจาก runtime polymorphism เป็นกลไกสำคัญที่ทำให้โค้ดขยายได้และบำรุงรักษาได้ การเชี่ยวชาญสิ่งเหล่านี้ โดยเฉพาะการ dispatch แบบ virtual/override ที่ทำให้ polymorphism ทำงานได้ จึงเป็นความรู้ที่สำคัญและถูกนำไปใช้บ่อยสำหรับการออกแบบเชิงวัตถุใน C# และเป็นหัวข้อสัมภาษณ์ที่พบบ่อยซึ่งเผยให้เห็นความเข้าใจในพื้นฐาน OOP