OOP : Inheritence

• Inheritence adalah sebuah mekanisme di mana suatu kelas dapat mewarisi sifat dari kelas lainnya.

• Inheritence memungkinkan pembuatan kelas baru yang disebut sebagai kelas turunan (derived class/subclass/child class).

• Kelas yang menjadi induk dari kelas turunan tersebut biasanya disebut sebagai kelas induk (base class/parent class/superclass).

• Kelas turunan dapat menggunakan metode yang telah ditulis dalam kelas induk, sehingga dapat mengurangi duplikasi kode.

Contoh dunia nyata.

Hubungan antara binatang dan anjing.

• Binatang adalah kategori umum yang mencakup berbagai makhluk hidup dengan sifat dasar seperti bernapas dan bergerak.

• Anjing, sebagai salah satu jenis dari binatang, mewarisi sifat-sifat ini tetapi juga memiliki karakteristik khusus, seperti menggonggong dan setia pada majikannya.

• Dalam ilustrasi ini, binatang disebut sebagai base class/parent clas/superclass, sedangkan anjing disebut sebagai derived class/child class/subclass, yang mewarisi sifat dasar dari binatang dan menambahkan sifat khasnya sendiri.

Contoh code.

Berikut adalah contoh pembuatan class untuk binatang (class Animal) dan anjing (class Dog).

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("Animal is eating.");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Dog is barking.");
    }
}

Berikut ini adalah contoh saat class anjing (yang merupakan turunan dari class Animal) di-inisialisasi menjadi sebuah objek.

Dog myDog = new Dog();
myDog.Eat();
myDog.Bark();

Pada kode diatas kita bisa melihat bahwa variabel myDog dideklarasikan dengan object type adalah ‘Dog’. Pada saat pemanggilan method, objek myDog dapat memanggil method Eat() yang merupakan method dari parent class ya yaitu ‘Animal’, tetapi sekaligus juga dapat memanggil method Bark() yang merupakan method unik milik class ‘Dog’ itu sendiri.

Aturan Inheritence yang harus diperhatikan.

Dalam penggunaan inheritence, ada beberapa aturan yang harus diperhatikan, diantaranya adalah sebagai berikut:

Aturan 1:

Child class dapat mengakses anggota dari parent class, tetapi parent class tidak pernah dapat mengakses anggota yang murni didefinisikan dalam child class.

// Contoh code 1
Dog myDog= new Dog ();
myDog.Eat();
myDog.Bark(); //Bagian ini TIDAK menghasilkan error.

// Contoh code 2
Animal myAnimal= new Animal();
myAnimal.Eat();
myAnimal.Bark(); //Bagian ini menghasilkan error.

Baris terakhir pada contoh code 2 diatas akan menghasilkan error, alasannya adalah karena Bark() merupakan method atau function khusus dari Dog yang adalah child class, bukan method milik Animal sebagai parent class dari Dog.

Aturan 2:

Kita dapat menginisialisasi variabel parent class dengan menggunakan instance child class. Dengan teknik ini, parent class akan berlaku sebagai reference variable.

Animal myAnimal= new Dog();
myAnimal.Eat();
myAnimal.Bark();

Pada deklarasi variabel diatas kita menginisialisasi variabel myAnimal dengan object type nya sebagai Dog. Pada baris terakhir kode tersebut, compiler akan mengenalinya sebagai error, mengapa? Karena saat compile time, compiler akan melakukan pengecekan pada reference variable (Sisi sebelah kiri), sedangkan object type (sisi sebelah kanan) akan dicek pada saat run time (kita akan melihat lebih jauh mengenai apa yang terjadi saat compile time dan run time pada topik Polymorphism). Karena saat compile time yang digunakan adalah reference variable (sisi sebelah kiri) dimana itu adalah class Animal, dan class tersebut tidak memiliki method/function Bark(), sehingga terjadi error.

Aturan 3:

Jika parent class memiliki constructor, maka constructor tersebut harus bisa diakses oleh child class.

public class Animal
{
    Animal() // Constructor dari parent class
    {
        Console.WriteLine("Animal Constructor is Called");
    }
    public void Eat()
    {
        Console.WriteLine("Animal is eating.");
    }
}

public class Dog : Animal
{
    public Dog() // Constructor dari child class
    {
        Console.WriteLine("Dog Constructor is Called");
    }
    public void Bark()
    {
        Console.WriteLine("Dog is barking.");
    }
}

Pada bagian di atas akan terjadi error karena constructor animal tidak mengijinkan untuk diakses oleh class lain di luar dirinya (default modifier pada class adalah private). Solusinya adalah dengan memberikan modifier yang mengijinkan child class untuk mengakses constructor dari parent class nya, contoh: Jika menambahkan access modifier “Public” pada constructor Animal, maka tidak akan terjadi error.

Aturan 4.

Jika constructor dari parent class diberi parameter, maka constructor child class tidak dapat secara implisit memanggil constructor parent nya tanpa melakukan passing parameter.

public class Animal
{
    public Animal(int number)
    {
        Console.WriteLine($"Animal Constructor is Called : {number}");
    }
    public void Eat()
    {
        Console.WriteLine("Animal is eating.");
    }
}

public class Dog : Animal
{
    // Saat membuat constructor untuk child class harus melakukan 
    // passing parameter untuk base class nya juga.
    // Jika tidak (kode ": base(10)" tidak ditulis), maka akan terjadi error.
    public Dog() : base(10)
    {
        Console.WriteLine("Dog Constructor is Called");
    }
    public void Bark()
    {
        Console.WriteLine("Dog is barking.");
    }
}

Perhatikan kode diatas, pada saat mendeklarasikan constructor pada child class, kita melakukan passing parameter ke constructor base class atau parent class nya, sehingga kode tersebut sudah benar dan tidak error. Namun jika “: base(10)“ tidak ditulis, yang artinya tidak ada passing parameter ke parent class, maka akan terjadi error.

Jenis-jenis inheritence.

Single Inheritence.

Di mana sebuah class, yang dikenal sebagai class turunan, didasarkan pada class lain, yang dikenal sebagai class dasar (base class atau parent class).

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("Animal is eating.");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Dog is barking.");
    }
}

Multilevel Inheritence.

Di mana sebuah class diturunkan dari class turunan lainnya, sehingga menciptakan rantai inheritence.

public class Grandfather
{
    public void Display()
    {
        Console.WriteLine("This is the grandfather class");
    }
}

public class Father : Grandfather
{
    public void Show()
    {
        Console.WriteLine("This is the father class");
    }
}

public class Child : Father
{
    public void DisplayChild()
    {
        Console.WriteLine("This is the child class");
    }
}

Hierarchical Inheritence.

Dimana beberapa class diturunkan dari satu base class, sehingga membentuk struktur seperti pohon.

public class Parent
{
    public void Display()
    {
        Console.WriteLine("This is the parent class");
    }
}

public class Child1 : Parent
{
    public void Show1()
    {
        Console.WriteLine("This is the first child class");
    }
}

public class Child2 : Parent
{
    public void Show2()
    {
        Console.WriteLine("This is the second child class");
    }
}

Secara ringkas kita dapat melihatnya dengan lebih jelas pada gambar berikut ini.

Kita sudah belajar mengenai konsep Inheritence pada OOP, selanjutnya kita akan melihat konsep berikutnya dari OOP yaitu Encapsulation.