Polymorphism

Reading Time: 4 minutes

කොහොමද ඉතින් ! oop වල මීලඟ පාඩම බලාපොරොත්තුවෙන් සිටි යාලුවෝ හැමෝම සාදරයෙන් පිලිගන්නවා..පුරුදු විදියටම මං කලින් පාඩම පොඩ්ඩක් මතක් කරලා ඉන්නම්කෝ…කලින් පාඩමේදී අපි කතා කලා upcasting හා downcasting කියන්නේ මොකද්ද කියලා හා කොහොමද අපි upcasting හා downcasting කරන්නේ කියලා.මොකක්ද අපි upcasting කිව්වේ?? upcasting කියලා අපි කිව්වේ…sub class object එකක් හදලා ඒක super class reference variable එකක store කරන එකට.. එහෙම super class reference variable එකක store කරපු sub class object එක නැවත sub class reference variable එකක store කරන එකට අපි කිව්වා downcasting කියලා.ඔන්න ඔය දෙක ගැන තමයි කලින් පාඩමේදී අපි කතා කලේ.මතක නැහැ වගේ නම් කලින් පාඩම පොඩ්ඩක් බලන් එන්න වෙනවා.නැත්තම් අද පාඩම තේරුම් ගන්න ට්කක් අමාරු වෙනවා.😯

හරි එහෙනම් ඔන්න ඔය කලින් පාඩමත් ඔලුවෙ තියාගෙනම අපි බලමුකෝ අද පාඩම මොකක්ද කියලා..අද පාඩම තමයි Polymorphism . oop වල තියෙන ඉතා වැදගත් පාඩමක් වගේම ගොඩ දෙනෙක් හරි හැටි තේරුම් නොගන්නා හරි ලේසි පාඩමක්.මේ blog post එකෙන් අපි හරියටම තේරුම් ගමු Polymorphism කියන්නේ මොකද්ද කියලා.

Polymorphism කියන වචනය හැදිලා තියෙන්නේ “Poly”  සහ “morphs”කියන ග්‍රීක වචන දෙකේ එකතුවෙන්.ඇත්තටම මේ polymorphism කියන එකේ සරල තේරුම් තමයි එක දෙයක් එම එහෙමත් නැත්නම්  action එකක්  ක්‍රම කිහිපයකින් සිදුකිරීමයි. polymorphism ‍ ප්‍රධාන වශයෙන් compile time polymorphism සහ runtime polymorphism කියලා කොටස් දෙකකට වෙන් කරන්න පුළුවන් .

කලින් පාඩමකින් අපේ සාකච්ඡා කළා නිේද method overloading ගැන. method overloading අපේ යාලුවන් ඔක්කොටම මතක ඇති කියලා හිතනවා. පොඩ්ඩක් හරි අමතක නම් මෙතනින් ගිහින් ඒ පාඩම පාඩමත් බලාගෙන එන්නකෝ.හරි දැන් මතක් උනා නේද method overloading ගැන. method overloading පාවිච්චි කරලා එක action එකක් ක්‍රම කිහිපයකින් කරනවට අපි කියනවා compile time polymorphism කියලා කියන්නේ. හරිම ලේසියි නේද…

නමුත් අපි අද කතා කරන්න යන්නේ runtime polymorphism ගැන. එහෙමත් නැත්නම් තවත් විදියකින් කියනවා නම් Dynamic method dispatch කියන එක ගැන.ඔන්න ඕක තමයි අපේ අද මාතෘකාව. හරි එහෙනම් අපි බලමු මොකද්ද මේ runtime polymorphism( Dynamic Method Dispatch) කියන්නේ කියලා

ඇත්තටම මේ පාඩම තේරුම් ගන්න නම් , inheritance,method overridding හා upcasting කියන පාඩම් තුනම ඕනි වෙනවා.ඔන්න ඔය පාඩම් තුනේ පොඩි හරි අව්ලක් තියනවානම් මේ පාඩමත් ටිකක් අමාරු වෙයි..ඒ නිසා ඔන්න ඔය පාඩම් තුන හරියටම තේරුම් ඇරන් ඉන්න ඕනි ඉස්සරෝම.

හරි runtime polymorphism( Dynamic Method Dispatch) කියලා කෙටියෙන්ම කියන්නම්කෝ මම. runtime polymorphism කියලා කියන්නේ sub class object store කර ගන්න super class reference variable එකක් හදාගෙන (upcasting) ඒ reference variable එක පාවිච්චි කරලා sub class එකේ හෝ sub class වල තියන attributes හා methods වලට call කරන එකට.ඇත්තටම මේ super class reference variable එක ඕනෑම sub class එකක object එකක් store කරන්න ගන්න පුලුවන් පොදු variable එකක්.තේරුනේ නෑ නේද…හරි හරි කලබල වෙන්න එපා මං උදාහරණයක් ඇරගෙන පැහැදිලි කරන්නම්.
වාහන වර්ග තුනක් ගන්නවා මං car, truck හා motorcycle කියලා.හරි අපි එහෙනන් ඉස්සරෝම class තුන හදලා ඉමුකෝ.

class Car{
      int numberOfWeels;
      String brand;
      String color;
      int speed;

      void park(){
           System.out.println("car is park at second flow !");
      }

      void driveFast(){
           // statement ;
      }

}

class Truck{
    int numOfWeels;
    String brand;
    String color;
    String weight;

    void park(){
         System.out.println("Truck is park at ground flow !");
    }

    void hoist(){
        // statement ;
    }
}


class Motorcycle{
     String brand;
     String color;
     int year;
     int numOfWeels;

     void park(){
         System.out.println("Truck is park at garden !");
     }

     void ride(){
          // statement ;
     }

}

ඔන්න ඔහොම තමයි class තුන එන්නේ…class තුනේම පොදු attributes හා methods තියෙන නිසා පොදු attributes හා methods එක class එකකට ගමු…ඒ ගන්න class එකට මං නමක් දෙනවා vehicle කියලා.

අපේ ඒ vehicle class එකෙන් car,truck හා motorcycle කියන class තුන inherit කරමු…එතකොට අපේ super class එක වෙනවා vehicle කියන class එක. sub classes වෙනවා car,truck හා motorcycle කියන class තුනම..ඔන්න ඔය ටික තේරුනා නේද?…ඔතෙන්ට එනකල්ම තිබුනේ inheritance පාඩම. class තුනටම park method එක පොදු නිසා ඒකත් super class එක තුළට දලා sub class වලදි park method එක override කරනවා .
code එක මේ වගේ නේද inherit කරලා ඉවර උනාම.

class Vehicle{
     int numberOfWeels;
     String brand;
     String color;
  
     void park(){
           // abstract body ;
     }

}

class Car extends Vehicle{
      int speed;

      void park(){
         System.out.println("Truck is park at second flow !");
     }


      void driveFast(){
           // statement ;
      }
}

class Truck extends Vehicle{
      int weight;

      void park(){
         System.out.println("Truck is park at ground flow !");
      }


      void hoist(){
        // statement ;
      }
}

class Motorcycle extends Vehicle{
      int year;

      void park(){
         System.out.println("Truck is park at garden !");
      }

      void ride(){
          // statement ;
      }

}

හරි ඔන්න ඔය විදියට අපි vehicle class කියන super class එකෙන් inherit කරලා car, truck හා motorcycle කියන sub class තුන හදාගෙන, vahicle එකේ තිබුන park method එක එක් එක් sub class එකේදී override කරලත් code එක ලියා ගත්තා..

මං runtime polymorphism කියලා කිව්වෙ මොකද්ද?..runtime polymorphism කියලා කිව්වේ sub class objects තියා ගන්න පුලුවන් එක පොදු reference variable එකක් හදාගෙන ඒ ඒ sub class වල තියන methods හා attributes වලට ඒ පොදු reference variable එක හරහා call කිරීමනේ….හරි එහෙනන් අපි පොදු reference variable එකක් හදා ගමු..කොහොමද අපි sub class objects තියා ගන්න පුලුවන් පොදු variable එකක් හදා ගන්නේ…. දැන් ඔයාලට මතක් වෙනවා නේද කලින් කරපු upcasting පාඩම ….අන්න ඒ පාඩමේ විදියට super class reference variable එකක් හදා ගත්තොත් පුලුවන් නේද sub class ඕනෑම object තියාගන්න.

class MyClass{
        public static void main(String a[]){

        Vehicle vehicle1; 

       }

}

හරි එහෙනන් පොදු reference variable එකකුත් හදා ගත්තා…දැන් sub class objects ඒ හදා ගත්තු පොදු variable එකේ store කරලා ඒ ඒ object එකේ attributes හා methods වලට call කරමු මෙන්න මේ විදියට..

class MyClass{
      public static void main(String a[]){

               Vehicle vehicle1; 

              vehicle1=new Car(); // storing car object in super class reference variable..
              vehicle1.park();

              vehicle1=new Truck(); // storing Truck object in super class reference variable..
              vehicle1.park();

              vehicle1=new Motorcycle(); // storing motorcycle object in super class reference variable..
              vehicle1.park();
      } 
}

output එක දිහාත් පොඩ්ඩක් බලන්නකෝ…methods call වෙලා තියනවා නේද…

හරි ඔන්න ඕකට තමයි runtime polymorphism( Dynamic Method Dispatch) කියලා කියන්නේ…කෙටියෙන් කියනවනං , sub classes objects තියා ගන්න පුලුවන් super class reference variable එකක් හදාගෙන ඒ reference variable එක පාවිච්චි කරලා sub class වල තියෙන attributes හා methods වලට call කරන එකටයි.runtime polymorphism( Dynamic Method Dispatch) කියන එකේ අදහස ඔන්න ඕකයි..පාඩම තේරුනා කියලා හිතනවා…මොකක් හරි අව්ලක් තිබ්බොත් කොමෙන්ටුවක් දාන්න ඕනි හොදේ..☺☺…මීලඟ පාඩමෙන් හමුවෙමු සුබ දවසක් !.