18. Polymorphism C# (Basic/Dasar)

Maksud dari kata polymorphism adalah bisa mempunyai banyak bentuk. Dalam dunia pemrograman berorientasi object (OOP) biasa diekspresikan sebagai satu interface yang mempunyai banyak fungsi.

Polymorphism dapat berupa dynamic atau static. Dalam static polymorphism, respon dari fungsi/method ditentukan pada saat waktu kompilasi program (Compile Time). Sedangkan pada dynamic polymorphism dilakukan pada saat program berjalan (Run Time).

Static Polymorphism

Mekanisme mengaitkan function/method pada sebuah object pada saat compile time desebut early binding atau juga disebut sebagai static binding. Dalam C# ada dua macam static binding yaitu:

• Function Overloading
• Operator Overloading

Kita akan mendiskusikan masalah Operator Overlaoding pada tutorial selanjutnya.

Function/Method Overloading

Kita dapat mendefinisikan fungsi/method dengan nama yang sama pada sebuah scope/class. Kita dapat membuat banyak fungsi/method dengan nama yang sama tetapi dengan parameter atau nilai kembalian yang berbeda.

Berikut adalah contoh program untuk mengilustrasikan overloading fungsi/method print():

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();
      }
   }
}

Setelah program dijalankan akan memberikan output sebagai berikut:

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

Dynamic Polymorphism

Dalam C# kita bisa mendefinisikan abstract class yang mengimplementasikan sebagian blueprint dari class, sehingga kita bisa memodifikasi class tersebut di class turunan. Abstract class terdiri dari abstract fungsi/method yang akan diimplementasikan pada class turunan.

Berikut adalah aturan dalam membuat abstract class:

• Kita tidak bisa secara langsung membuat instance object dari abstract class
• Kita tidak bisa mendefinisikan fungsi/method abstract di luar abstract class
• Ketika class didefinisikan sebagai sealed class tersebut tidak bisa diturunkan oleh class yang lain, maka dari itu abstract class tidak dapat didefinisikan dengan sealed.

Berikut adalah program untuk mengilustrasikan abstract class dalam dynamic polymorphism:

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 program dijalankan akan memberikan keluaran sebagi berikut:

Rectangle class area :
Area: 70

Selain dengan menggunakan abstract class, kita juga bisa mendefinisikan fungsi/method sebagai virtual sehingga kita bisa mengimplementasikan fungsi/method pada child class.

Dari sini bisa kita simpulkan kalau dynamic overloading bisa diimplementasikan menggunakan:

• Abstract Class
• Fungsi/Method dengan definisi sebagai virtual

Program dibawah ini mengilustrasikan penggunaan fungsi/method virtual:

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();
      }
   }
}

Setelah program dijalankan akan memberikan output sebagai berikut:

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

Ok guys tetap semangat ya, sampai ketemu di tutorial selanjutnya Operator Overloading.