Inheritance C#: Kuasai Pewarisan Fitur Class dengan Mudah

Wih, gaes! Pernah gak sih lu ngerasa capek ngoding hal yang sama berulang-ulang? Kayak bikin kelas MobilSport terus bikin kelas MobilKeluarga, eh ternyata dua-duanya punya fitur Jalan() dan Rem() yang sama persis. Nah, di sini lah Inheritance alias pewarisan jadi penyelamat kita. Ini dia cara C# bikin kode lu makin effortless tapi tetep powerful.

Spill Tuntas Konsep Inheritance: Apa Sih Vibes-nya?

Singkatnya, inheritance itu kayak lu di dunia nyata. Lu mewarisi beberapa sifat dari orang tua lu kan? Nah, di C#, kelas bisa mewarisi fitur (properti dan method) dari kelas lain.

• Kelas Induk (Base Class/Parent Class): Ini kelas yang punya fitur-fitur dasar. Ibaratnya, ini adalah orang tua lu.
• Kelas Anak (Derived Class/Child Class): Ini kelas yang "mewarisi" fitur dari kelas induk. Ibaratnya, ini adalah lu yang dapat "warisan" dari orang tua.

Kenapa keren?

• Reusability (Kode Bisa Dipakai Ulang): Lu gak perlu nulis kode yang sama lagi. Cukup definisiin di kelas induk, nanti kelas anak tinggal "ambil".
• Organisasi Kode: Bikin struktur kode lu jadi lebih rapi dan gampang dibaca.
• Hierarki yang Logis: Membantu membangun hubungan antar kelas yang masuk akal.

Gimana Caranya Skuy Gaskeun di C#?

Di C#, kita pake simbol titik dua (:) buat ngasih tau kalo satu kelas mewarisi dari kelas lain. Gampang kan?

Contoh Nyata Biar Makin Kece:

Misal kita mau bikin hierarki kelas buat berbagai jenis kendaraan.

// Kelas Induk (Base Class)
public class Kendaraan
{
    public string Merk { get; set; }
    public int TahunProduksi { get; set; }

    public Kendaraan(string merk, int tahun)
    {
        Merk = merk;
        TahunProduksi = tahun;
    }

    public void Klakson()
    {
        Console.WriteLine("Beep! Beep!");
    }

    public virtual void Bergerak() // 'virtual' penting buat di-override nanti
    {
        Console.WriteLine("Kendaraan sedang bergerak...");
    }
}

// Kelas Anak (Derived Class) - Mewarisi dari Kendaraan
public class Mobil : Kendaraan
{
    public int JumlahPintu { get; set; }

    // Constructor kelas anak harus panggil constructor kelas induk pakai 'base'
    public Mobil(string merk, int tahun, int pintu) : base(merk, tahun)
    {
        JumlahPintu = pintu;
    }

    // Meng-override method dari kelas induk
    public override void Bergerak()
    {
        Console.WriteLine($"Mobil {Merk} beroda empat melaju di jalan!");
    }
}

// Kelas Anak Lain - Mewarisi dari Kendaraan
public class Motor : Kendaraan
{
    public int KapasitasMesin { get; set; }

    public Motor(string merk, int tahun, int kapasitas) : base(merk, tahun)
    {
        KapasitasMesin = kapasitas;
    }

    public override void Bergerak()
    {
        Console.WriteLine($"Motor {Merk} berkapasitas {KapasitasMesin}cc siap ngegas!");
    }
}

// Main program buat nyobain
public class Program
{
    public static void Main(string[] args)
    {
        Mobil mobilSaya = new Mobil("Toyota", 2022, 4);
        Motor motorSaya = new Motor("Honda", 2023, 150);

        Console.WriteLine($"Mobil: {mobilSaya.Merk}, Tahun: {mobilSaya.TahunProduksi}, Pintu: {mobilSaya.JumlahPintu}");
        mobilSaya.Klakson(); // Fitur dari kelas induk
        mobilSaya.Bergerak(); // Fitur yang di-override

        Console.WriteLine("\n---");

        Console.WriteLine($"Motor: {motorSaya.Merk}, Tahun: {motorSaya.TahunProduksi}, Kapasitas: {motorSaya.KapasitasMesin}cc");
        motorSaya.Klakson(); // Fitur dari kelas induk
        motorSaya.Bergerak(); // Fitur yang di-override
    }
}

Penjelasan Keren:

• Kelas Mobil dan Motor pake : Kendaraan. Ini artinya, mereka otomatis punya properti Merk dan TahunProduksi serta method Klakson() dari kelas Kendaraan.
• Di constructor Mobil dan Motor, ada : base(merk, tahun). Ini penting banget! Lu wajib manggil constructor kelas induk dulu buat inisialisasi fitur-fitur yang diwarisi.
• Method Bergerak() di kelas Kendaraan dikasih keyword virtual. Ini ngasih tau C# kalo method ini bisa di-"ganti" atau di-override sama kelas anak.
• Di kelas Mobil dan Motor, kita pake public override void Bergerak(). Ini yang namanya Method Overriding. Jadi, ketika Bergerak() dipanggil di objek Mobil atau Motor, versi method yang spesifik untuk kelas anak yang akan jalan, bukan yang di kelas induk. Ini bikin kode jadi lebih fleksibel.

Tips Biar Makin GG dan Hindari Jebakan Batman

1. Jangan Berlebihan Pewarisan: Gunakan inheritance kalo memang ada hubungan "is-a" yang logis (misal: Mobil is-a Kendaraan). Kalo hubungannya "has-a" (Mobil has-a Engine), mending pake Composition.
2. Gunakan protected: Kalo lu mau properti atau method itu bisa diakses sama kelas induk dan kelas anak, tapi gak dari luar, pake protected.
3. Pahami abstract dan sealed:
   • abstract class: Kelas yang gak bisa di-instansiasi langsung, tapi wajib di-override method-methodnya sama kelas anak. Mirip kayak template.
   • sealed class: Kelas yang gak bisa diwariskan lagi. Biar fitur-fiturnya gak diubah-ubah sama kelas lain.
4. Constructor Inheritance Rules: Ingat, kelas anak selalu memanggil constructor kelas induk. Kalo kelas induk gak punya constructor default (tanpa parameter), lu harus spesifikin di constructor kelas anak buat manggil constructor kelas induk pake base().

Inheritance itu powerful banget, gaes. Dengan paham konsep ini, lu bisa bikin kode yang lebih bersih, efisien, dan gampang di-maintain. Yuk, gaskeun ngoding pake inheritance!