OOP : Polymorphism

• Secara hurufiah “Poly” artinya banyak, “Morph” artinya bentuk. Jadi Polymorphism = memiliki banyak bentuk.

• Polymorphism adalah konsep dalam Pemrograman Berorientasi Objek (PBO) dimana sebuah entitas (variable, object, method) dapat berubah menjadi bentuk lainnya.

Contoh dalam dunia nyata.

Kita ambil contoh seseorang yang bisa memiliki banyak peran dalam hidupnya.

• Di Kantor, Pria A berperilaku seperti karyawan.

• Di Mall, Pria A berperilaku seperti pelanggan.

• Di Rumah, Pria A berperilaku seperti seorang ayah.

Polymorphism dapat dilakukan melalui 2 cara.

• Compile time Polymorphism (Method Overloading).

• Run-time Polymorphism (Method Overriding).

Compile time Polymorphism (Method Overloading).

Terjadi ketika beberapa method memiliki nama yang sama namun memiliki parameter yang berbeda (baik dalam jumlah, tipe, atau urutan).

Method overloading bisa dilakukan dalam beberapa kondisi.

• Dilakukan pada method dalam class yang sama.

• Dilakukan pada method dalam child class.

• Dilakukan pada constructor.

Beberapa aturan dalam melakukan Method Overloading.

• Parameternya harus berbeda (jumlah, tipe, atau urutan).

• Return type saja tidak dapat membedakan method yang di-overload.

• Terjadi pada saat kompilasi (juga disebut Compile time Polymorphism).

Contoh code: Method overloading pada class yang sama.

public class Person
{
    public int SummingUp(int a, int b)
    {
        return a + b;
    }
    public int SummingUp(int a, int b, int c)
    {
        return a + b + c;
    }
    public double SummingUp(double a, double b)
    {
        return a + b;
    }
}

Pada code di atas kita bisa melihat bahwa ada 3 method dengan nama yang sama dalam satu class. Meskipun namanya sama, ketiga method ini memiliki parameter yang berbeda, sehingga compiler mengenalinya sebagai method yang berbeda pula, dan tidak akan terjadi error.

Contoh code: Inheritence-based method overloading.

class Person1
{
    public void SummingUp(int a, int b)
    {
        Console.WriteLine(a + b);
    }
    public void SummingUp(float x, float y)
    {
        Console.WriteLine(x + y);
    }
}
class Person2 : Person1
{
    public void SummingUp(string s1, string s2)
    {
        Console.WriteLine(s1 +" "+ s2);
    }
}

Pada code di atas, kita melakukan method overloading pada class yang berbeda, tetapi masih merupakan turunan dari class sebelumnya. Dengan cara ini, compiler juga dapat mengenali method tersebut sebagai method yang berbeda sehingga cara ini dapat dilakukan tanpa menimbulkan error.

Contoh code: Constructor Overloading.

class Person
{
    int x, y, z;
    public Person(int x)
    {
        Console.WriteLine("Constructor1 Called");
        this.x = 10;
    }
    public Person(int x, int y)
    {
        Console.WriteLine("Constructor2 Called");
        this.x = x;
        this.y = y;
    }
    public Person(int x, int y, int z)
    {
        Console.WriteLine("Constructor3 Called");
        this.x = x;
        this.y = y;
        this.z = z;
    }
    public void Display()
    {
        Console.WriteLine($"X={x}, Y={y}, Z={z}");
    }
}

Person obj1 = new Person(10);
obj1.Display();
Person obj2 = new Person(10, 20);
obj2.Display();
Person obj3 = new Person(10, 20, 30);
obj3.Display();

Pada code diatas, kita melakukan method overloading pada constructor berikut dengan contoh implementasinya saat melakukan inisialisasi. Cara ini sangat menguntungkan karena seandainya suatu ketika kita ingin menambahkan parameter pada constructor, kita tidak perlu merubah logic yang sudah kita buat sebelumnya saat deklarasi objek. Kita cukup membuat constructor yang baru dengan parameter yang berbeda dan kita dapat memanggilnya dengan menyesuaikan jumlah dan tipe parameternya.

Runtime Polymorphism (Method Overriding).

• Method overriding terjadi ketika child class mengimplementasikan secara spesifik method yang telah didefinisikan di dalam parent class nya. Method yang mengijinkan untuk di-override perlu ditambahkan modifier virtual.

• Dilakukan dengan menambahkan kata kunci*‘override’* pada method yang melakukan override.

• Tujuannya adalah agar child class dapat mengganti perilaku method yang diwarisi dari parent class nya.

Beberapa aturan dalam melakukan Method Overriding.

• Modifier pada method parent class perlu ditambahkan “virtual” dan modifier pada method child class perlu ditambahkan “override”.

• Method pada child class harus memiliki nama, return type, dan parameter yang sama dengan parent class nya.

• Terjadi pada saat runtime (disebut juga runtime polymorphism).

Kapan kita perlu melakukan override sebuah method? Jika logika dalam method parent class tidak dapat memenuhi persyaratan bisnis dari child class.

Berikut contoh code nya.

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("The animal makes a sound.");
    }
}
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("The dog barks.");
    }
}
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("The cat meows.");
    }
}

Animal myAnimal = new Animal();
myAnimal.Speak(); // "The animal makes a sound."
myAnimal = new Dog();
myAnimal.Speak(); // "The dog barks."
myAnimal = new Cat();
myAnimal.Speak(); // "The cat meows."

Pada contoh code diatas, kita melakukan method overriding pada method Speak(). Pada prent class, kita awalnya sudah menentukan implementasi dari method Speak(), namun pada child class, kita melakukan override dengan memberikan implementasi baru pada method Speak(). Sehingga ketika class tersebut di-inisialisasi menjadi objek, kita dapat memanggil method tersebut dan menghasilkan output yang berbeda sesuai dengan Object Type yang kita gunakan.

Catatan:

• Jika tidak ada method override pada child class, maka yang akan dieksekusi adalah method dari parent class nya.

• Contoh: Jika kita menghapus method Speak() pada class Cat, maka pada saat mengeksekusi method Speak() untuk object type Cat, outputnya adalah: “The animal make a sound”, bukan “The cat meows“ lagi.

Apa yang sebenarnya terjadi saat compile time dan run time?

• Saat compile time, compiler melakukan cek kepada reference type.

• Saat run time, CLR melakukan cek kepada object type.

• Inilah alasan mengapa disebut compile-time polymorphism dan runtime polymorphism.

Akibatnya adalah ketika ada kesalahan implementasi yang berkaitan dengan object type, maka error tidak akan terdeteksi saat compile time, karena penulisan dianggap sudah benar. Namun ketika dijalankan saat runtime, barulah error tersebut akan muncul dan ketahuan.

Kita sudah belajar mengenai konsep Polymorphism pada OOP, selanjutnya kita akan melihat konsep terakhir dari OOP yaitu Abstraction.