Object Oriented Methodology- Polymorphism සවිස්තරාත්මකව

Polymorphism  කියන්නේ OOP වල ඇති වැදගත්ම සංකල්පයයි. මෙය හොදින්ම තේරුම් ගැනීම වැදගත් නිසා  මෙය වෙනම සම්පූර්ණ ලිපියකින් දක්වන්න සිතුවා. Polymorphism  හැදෙන්නේ ග්‍රික බාසාවේ Poly(සිංහල බාසාවේ බහු යන පදය හැදින් වීමට භාවිතා වන ග්‍රික වචනයයි) හා morph(සිංහල බාසාවේ ආකාරය යන පදය හැදින් වීමට භාවිතා වන ග්‍රික වචනයයි) යන වචන දෙක එක් වෙමිනි.

මෙහිදි Polymorphism  මගින් කියැවෙන්නේ Object එකකට විවිධ අකාර ගැනීමේ ඇති හැකියාවයි. එමෙන්ම එය ක්‍රමලේඛකරුවන්ට(Programmers) පහසුවෙන් වටහා ගත හැකි  නැවත නැවත භාවිතා කළ හැකි(reuse) මෘදුකාංග නිර්මාණය කිරීමට උපකාරී වේ.

Polymorphism ක්‍රමලේඛකරුවා හට requirement  මත depend වන විවිධ operations සහිත තනි method අඩංගු ක්‍රමලේඛ ලිවිමට නම්‍යශීලී භාවය ලබාදේ.

Java තුළදි තනි interface(ක්‍රමලේඛනයක public methods ටික body එක නැතුව නමයි return type එකයි parametersටිකයි දාලා හදන class වගේ code එකක්) මගින් අනෙක් concrete class( abstract method අඩංගු නොවන class) නිරූපනය කළ හැක. එලෙස ඒ interface එක refer කරලා හදන Object එකහි method එකක් ගත්තොත් inputs අනුව method  වල හැසිරිම වෙනස් වේ.

උදාහරණයක් ලෙස ATM account එකක් සලකමු. එහිදි Credit card, Debit card හා Other cards තියෙනවා. නමුත් card වර්ගය මුලදීම හරියට දන්නේ  නැති නිසා ඉහත card වලට Object කලින් හදලා තියාගන්නත් බහැ. මන්ද Credit card අර්ථ දක්වලා, Debit card දුන්නොත් එතැන card, match වෙනනේ  නැති ප්‍රශ්නේ එනවනේ. තවද මෙම card  තුනම මුදල් ආපසු ගැනීම(withdraw), මුදල් තැන්පක් කිරීම (deposit), ශේෂය පරික්ෂා (checkBalance) කිරීම ආදී ය පොදු සිදු කරන method වේ.

ඒ කියන්නේ CreditCard c1=new DebitCard(); කියලා දෙනවා වගේ තමා. මේක තනිකරම වැරදියි. මේකට විසදුමක් විදිහට තමයි Polymorphism ආවේ. ඒ කියන්නේ Credit card, Debit card හා Other cards වලට පොදු super class හදන්න ඕනෑ. එය මං Card කියලා දානවා. දැන් අපට පුලුවන් Card එකට variable එකක් හදලා  ATM එකට එන Card වර්ගය අනුව Object  හදලා  ඉහත සදහන් කළ method call කිරීම සිදු කරයි. ඒ කියන්නේ Card වර්ගය  අනුව define කළ method එක වෙනස් වේ.

උදාහරණය

1. class Card{
2.    public void deposit(){
3.       //do some thing, you can use this as abstract method
4.    }
5.    public void withdraw(){
6.       //do some thing, you can use this as abstract method
7.    }
8.    public void balance(){
9.       //do some thing, you can use this as abstract method
10.    }
11. }
12. class CreditCard  extends Card {
13.    public void deposit(){
14.       //Credit card, deposit money operations
15.    }
16.    public void withdraw(){
17.       //Credit card, withdraw money operations
18.    }
19.    public void balance(){
20.       //Credit card, check balance operations
21.    }
22. }
23. class DebitCard extends Card {
24.    public void deposit(){
25.       //Debit card, deposit money operations
26.    }
27.    public void withdraw(){
28.       //Debit card, withdraw money operations
29.    }
30.    public void balance(){
31.       //Debit card, check balance operations
32.    }
33. }
34. class Demo{
35.    Card card;
36.    
37. 
    
38.    public static void main(String[] args){
39.       System.out.println("Please enter your card!");
40.       String card_type=scan.next();
41.       card=selectCard(card_type); //මෙතැන input අනුව Object එක වෙනස් වේ.
42.       card.balance();
43.       //this is not a correct logic. this is an only example
44.    }
45. 
    
46.    private Card selectCard(String cardType){
47.       if(cardType.equals("credit"))
48.          return new CreditCard();
49.       else if(){
50.          return new DebitCard();
51.       }
52.    }
53. }

Polymorphism වර්ග 

Java වලදි Polymorphism වර්ග දෙකක් ගැන කියැවේ.

• Run-time Polymorphism(dynamic polymorphism)
• Compile-time Polymorphism(static polymorphism)

Compile-time polymorphism

Program එක compile වෙනකොට සිදුවෙන කොට සිදු වේ නම් ඒවා Compile time polymorphism ලෙස හදුන්වයි. මෙහිදි call කරන method එක Compiler එක තීරණය කරයි. මෙයට හොදම උදාහරණය වන්නේ Method overloading වීමයි. මෙය Static binding, Early binding හා overloading යන නම් තුනෙන්ම හදුන්වනවා.
සෑම දෙයක්ම Compile time එකේදී ක්‍රියත්මක වන නිසා මේකේ flexibility එක අඩුයි.

Method overloading කියන්නේ එකම method name එකකින් වෙනස් ආකාර වලට  method අර්ථ දැක්වීමයි. විවිධ parameters වර්ග යොදා, වෙනස් වෙනස් return type යොදා එකම නමින් ඇති method බොහාමයක් සාදා ගත හැක.

1. public int add(int a, int b){
2.    return a+b;
3. }
4. public int add(int a, int b, int c){
5.    return a+b+c;
6. }
7. 
   
8. public static void main(String args[]){
9.    System.out.println("Total of 3+4 is "+add(3, 4));
10.    System.out.println("Total of 3+4+5 is "+add(3, 4, 5));
11. }

Runtime polymorphism

Program එක run වෙනකොට සිදුවෙන කොට සිදු වේ නම් ඒවා Runtime polymorphism ලෙස හදුන්වයි. මෙහිදි call කරන method එක Compiler එක තීරණය නොකරයි. මෙය inheritance වලදි  super class එකේ method එක sub class එකේ method වලින් overriding අවස්ථා වලදී දැක ගත හැක. මෙය Dynamic binding(Dynamic binding dispatch), Late binding හා overriding  යන නම් තුනෙන්ම හදුන්වනවා.

සෑම දෙයක්ම Run time එකේදී ක්‍රියත්මක වන නිසා මේකේ flexibility එක වැඩියි.
මෙහිදි Compile time polymorphism එක Runtime polymorphism එකට වඩා වේගවත් වේ.

උදාහරණය

1. class Bike{  
2.   void run(){System.out.println("running");}  
3. }  
4. class Splendor extends Bike{  
5.   void run(){System.out.println("running safely with 60km");}  
6.   
7.   public static void main(String args[]){  
8.     Bike b = new Splendor();//upcasting  
9.     b.run();  
10.   }  
11. }