C# – Polymorphism

Kata polymorphism artinya punya banyak bentuk. Dalam paradigma pemrograman berorientasi objek, polymorphism sering diungkapkan sebagai ‘satu antarmuka, banyak fungsi’.

Polymorphism bisa jadi statis atau dinamis. Dalam polymorphism statis, respon terhadap suatu fungsi ditentukan saat waktu kompilasi. Dalam polymorphism dinamis, responnya ditentukan saat waktu eksekusi program.

Static Polymorphism

Proses menghubungkan suatu fungsi dengan objek saat waktu kompilasi disebut sebagai binding awal. Ini juga disebut sebagai binding statis. C# menyediakan dua teknik untuk menerapkan polymorphism statis. Mereka adalah:

• Function overloading
• Operator overloading

Kita akan membahas overloading operator di bab selanjutnya.

Function Overloading

Kamu bisa punya beberapa definisi dengan nama fungsi yang sama dalam satu ruang lingkup. Definisi fungsi harus berbeda satu sama lainnya berdasarkan tipe dan/atau jumlah argumen di dalam daftar argumen. Kamu nggak bisa melakukan overloading pada deklarasi fungsi yang hanya berbeda berdasarkan return tipe.

Contoh berikut ini menunjukkan penggunaan fungsi print() untuk mencetak berbagai tipe data yang berbeda:

using System;

namespace PolymorphismApplication {
   class Printdata {
      void print(int i) {
         Console.WriteLine("Printing int: {0}", i );
      }
      void print(double f) {
         Console.WriteLine("Printing float: {0}" , f);
      }
      void print(string s) {
         Console.WriteLine("Printing string: {0}", s);
      }
      static void Main(string[] args) {
         Printdata p = new Printdata();
         
         // Call print to print integer
         p.print(5);
         
         // Call print to print float
         p.print(500.263);
         
         // Call print to print string
         p.print("Hello C++");
         Console.ReadKey();
      }
   }
}

Ketika kode di atas di-compile dan dijalankan, hasilnya bakal muncul seperti ini:

Printing int: 5
Printing float: 500.263
Printing string: Hello C++

Dynamic Polymorphism

Di C#, kamu bisa bikin kelas abstrak yang digunakan buat ngasih implementasi sebagian kelas dari suatu interface. Implementasinya diselesaikan ketika ada kelas turunan yang menginherit dari kelas abstrak tersebut. Kelas abstrak berisi method-method abstrak, yang diimplementasikan oleh kelas turunan. Kelas turunan punya fungsionalitas yang lebih spesifik.

Berikut ini aturan-aturan tentang kelas abstrak:

• Nggak bisa bikin instance dari kelas abstrak.

• Nggak bisa deklarasikan method abstrak di luar kelas abstrak.

• Ketika suatu kelas dideklarasikan sebagai sealed, itu artinya nggak bisa diwariskan. Kelas abstrak nggak bisa dideklarasikan sebagai sealed.

Contoh program berikut ini nunjukin kelas abstrak:

using System;

namespace PolymorphismApplication {
   abstract class Shape {
      public abstract int area();
   }
   
   class Rectangle:  Shape {
      private int length;
      private int width;
      
      public Rectangle( int a = 0, int b = 0) {
         length = a;
         width = b;
      }
      public override int area () { 
         Console.WriteLine("Rectangle class area :");
         return (width * length); 
      }
   }
   class RectangleTester {
      static void Main(string[] args) {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("Area: {0}",a);
         Console.ReadKey();
      }
   }
}

Ketika kode di atas di-compile dan dijalankan, hasilnya bakal muncul seperti ini:

Rectangle class area :
Area: 70

Kalo kamu punya fungsi yang didefinisikan di dalam suatu kelas dan kamu pengen fungsi itu diimplementasikan di kelas-kelas turunan, kamu bisa pake fungsi virtual. Fungsi virtual bisa diimplementasikan beda-beda di kelas turunan dan pemanggilan fungsi-fungsi ini bakal ditentuin saat runtime.

Polymorphism dinamis diimplementasikan dengan kelas abstrak dan fungsi virtual.

Berikut ini contoh program yang menunjukkan hal ini:

using System;

namespace PolymorphismApplication {
   class Shape {
      protected int width, height;
      
      public Shape( int a = 0, int b = 0) {
         width = a;
         height = b;
      }
      public virtual int area() {
         Console.WriteLine("Parent class area :");
         return 0;
      }
   }
   class Rectangle: Shape {
      public Rectangle( int a = 0, int b = 0): base(a, b) {

      }
      public override int area () {
         Console.WriteLine("Rectangle class area :");
         return (width * height); 
      }
   }
   class Triangle: Shape {
      public Triangle(int a = 0, int b = 0): base(a, b) {
      }
      public override int area() {
         Console.WriteLine("Triangle class area :");
         return (width * height / 2); 
      }
   }
   class Caller {
      public void CallArea(Shape sh) {
         int a;
         a = sh.area();
         Console.WriteLine("Area: {0}", a);
      }
   }  
   class Tester {
      static void Main(string[] args) {
         Caller c = new Caller();
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         
         c.CallArea(r);
         c.CallArea(t);
         Console.ReadKey();
      }
   }
}

Ketika kode di atas di-compile dan dijalankan, hasilnya bakal muncul seperti ini:

Rectangle class area:
Area: 70
Triangle class area:
Area: 25