Bagaimana cara kerja inheritance dan polymorphism?

Question

Accepted Answer

**Inheritance** memungkinkan sebuah class menurunkan dari base class, menggunakan kembali dan memperluas anggotanya. **Polymorphism** memungkinkan Anda memperlakukan object turunan melalui tipe base, dengan method yang di-override yang benar dipanggil saat runtime (melalui `virtual`/`override`). Ini adalah mekanisme OOP inti di 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"
```

Sebuah derived class (`Dog : Animal`) mewarisi anggota base dan dapat menambahkan miliknya sendiri. C# mendukung **single inheritance** (satu base class). `base.Method()` memanggil implementasi base.

## 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` yang di-override dalam derived class di-dispatch pada **runtime** berdasarkan tipe aktual object — jadi panggilan yang sama (`a.MakeSound()`) melakukan hal berbeda per tipe. Ini memungkinkan kode yang fleksibel dan dapat diperluas (menangani banyak tipe secara seragam).

## Abstract classes dan 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 classes** mendefinisikan base parsial (dengan abstract method yang subclass harus implementasikan ditambah kode bersama); `sealed` mencegah inheritance lebih lanjut.

## Mengapa ini penting

Inheritance dan polymorphism adalah mekanisme OOP inti di C#, fundamental untuk object-oriented design dan bekerja dengan framework .NET (yang menggunakannya secara ekstensif), jadi memahaminya sangat penting. **Inheritance** menyediakan code reuse melalui relasi "is-a" (Dog adalah Animal), meskipun C# hanya memungkinkan single inheritance. **Polymorphism** — melalui `virtual`/`override` dan runtime method dispatch — sangat penting: memungkinkan Anda memperlakukan tipe turunan berbeda secara seragam melalui tipe base sementara perilaku spesifik tipe yang benar berjalan otomatis, memungkinkan design yang fleksibel dan dapat diperluas (proses koleksi shapes berbeda, masing-masing menghitung area-nya sendiri).

Memahami mekanisme `virtual`/`override` (base menandai method yang dapat di-override, derived class meng-override-nya, dan runtime men-dispatch ke versi tipe aktual), **abstract classes** (base parsial dengan method yang subclass harus implementasikan ditambah kode bersama), dan `sealed` (mencegah inheritance) diperlukan untuk merancang class hierarchies dan memahami bagaimana framework .NET dan libraries distruktur.

Karena inheritance dan polymorphism mendasari C# object-oriented dan framework itu sendiri, dan karena runtime polymorphism adalah enabler kunci dari kode yang dapat diperluas dan dapat dipertahankan, menguasai ini — terutama virtual/override dispatch yang membuat polymorphism bekerja — adalah pengetahuan penting yang sering diterapkan untuk object-oriented design di C#, dan topik interview umum yang mengungkapkan pemahaman tentang fundamental OOP.