පොලිමෝෆිස්ම් (Polymorphism) - ලේසියෙන් තේරුම් ගමු | SC Guide

මචංලා, Software Engineering කියන ලෝකේ අපි හැමෝටම නිතරම වගේ ඇහෙන වචනයක් තමයි Object-Oriented Programming (OOP) කියන්නේ. ඒක හරියට අපේ Software හදන වැඩේට පොඩි හයියක් දෙන Framework එකක් වගේ. OOP වල මූලික කුළුණු හතරක් තියෙනවා: Abstraction, Encapsulation, Inheritance, සහ Polymorphism.

මේවායින් ගොඩක් අය ටිකක් ගල් ගහන, පොඩ්ඩක් සංකීර්ණයි වගේ පේන, හැබැයි නියමෙටම ප්‍රයෝජනවත් වෙන එකක් තමයි Polymorphism කියන්නේ. අද අපි මේ Polymorphism කියන සංකල්පය ගැන හොඳට, ලේසියෙන් තේරෙන විදියට කතා කරමු.

සූදානම්ද? එහෙනම් පටන් ගමු!

පොලිමෝෆිස්ම් (Polymorphism) කියන්නේ මොකක්ද? - මූලික අදහස

Polymorphism කියන වචනය ආවේ ග්‍රීක භාෂාවෙන්. "Poly" කියන්නේ "බොහෝ" කියන එක. "Morph" කියන්නේ "හැඩය" නැත්නම් "ආකාරය" කියන එක. එතකොට, Polymorphism කියන්නේ "බොහෝ ආකාර" කියන එකයි. Software Engineering වලට මේක කොහොමද සම්බන්ධ වෙන්නේ කියලා බලමු.

සරලවම කිව්වොත්, Polymorphism කියන්නේ එකම Method එකකට, විවිධ Objects වලට විවිධ ආකාරයෙන් Respond කරන්න පුළුවන් හැකියාවට. ඒ කියන්නේ, එකම නමින් තියෙන Method එකක් වුණත්, අපි ඒක Call කරන Object එක අනුව ඒකේ හැසිරීම වෙනස් වෙන්න පුළුවන්. හරියටම Remote Control එකක් වගේ හිතන්න. ඒකේ Power Button එක ඔබනකොට TV එක On/Off වෙනවා. හැබැයි AC Remote එකේ Power Button එක ඔබනකොට AC එක On/Off වෙනවා. Button එක "Power" වුණාට, ඒක වැඩ කරන විදිය Device එක අනුව වෙනස් වෙනවා වගේ තමයි මේකත්.

OOP වලදී මේක ප්‍රධාන වශයෙන් ක්‍රියාත්මක වෙන්නේ Inheritance හරහා. Parent Class එකක තියෙන Method එකක්, ඒකෙන් Inherit වෙන Child Class වලදී වෙනස් විදියකට Implement කරන එක (Method Overriding) Polymorphism වලට හොඳම උදාහරණයක්.

ඩක් ටයිපින් (Duck Typing) කියන්නේ මොකක්ද?

Polymorphism කතා කරනකොට "Duck Typing" කියන සංකල්පය ගැනත් කතා කිරීම වැදගත්. මේක විශේෂයෙන් Python වගේ Dynamically Typed Languages වලදී ගොඩක් වැදගත් වෙනවා. "If it walks like a duck and quacks like a duck, then it's a duck." කියන කියමන තමයි මේකේ මූලික අදහස. ඒ කියන්නේ, Object එකක වර්ගය (Type) ගැන හිතන්නේ නැතුව, ඒ Object එකේ තියෙන Methods සහ Properties ගැන විතරක් අවධානය යොමු කරන එකටයි Duck Typing කියන්නේ.

සරලවම, අපිට Method එකක් Call කරන්න පුළුවන් නම්, ඒ Object එකේ Type එක මොකක්ද කියලා වැඩක් නෑ. උදාහරණයක් විදියට, Animal කියන Base Class එකක් නැතිව වුණත්, makeSound() කියන Method එක තියෙන ඕනම Object එකකට process_sound() කියන Function එකට යවන්න පුළුවන්.

කෝඩ් වලින් තේරුම් ගමු: ප්‍රායෝගික උදාහරණයක්

කතාවෙන් විතරක් තේරෙන්නේ නෑනේ. අපි පොඩි කෝඩ් කෑල්ලක් ලියලාම මේක තේරුම් ගමු. මම මේකට Python පාවිච්චි කරනවා, මොකද ඒක ලේසියෙන් තේරුම් ගන්න පුළුවන් නිසා.

අපිට Animal කියන Class එකක් තියෙනවා කියලා හිතමු. ඒ Animal Class එකට makeSound() කියලා Method එකක් තියෙනවා.

class Animal:
    def makeSound(self):
        print("සතෙක් හඬ නගනවා...") # An animal makes a sound...

class Dog(Animal):
    def makeSound(self):
        print("බුරනවා... භව් භව්!") # Barks... woof woof!

class Cat(Animal):
    def makeSound(self):
        print("මියව්... මියව්!") # Meow... meow!

class Cow(Animal):
    def makeSound(self):
        print("අම්බරනවා... මූ!") # Moos... moo!

මේ Classes ටික දිහා බලන්න. Dog, Cat, සහ Cow කියන Classes ටික Animal Class එකෙන් Inherit වෙනවා. හැම Class එකකම makeSound() කියන එකම නමින් Method එකක් තියෙනවා. හැබැයි ඒ Method එකේ ඇතුලේ තියෙන Logic එක Class එක අනුව වෙනස් වෙනවා.

දැන් අපි මේවා Polymorphism හරහා කොහොමද පාවිච්චි කරන්නේ කියලා බලමු.

# Different animal objects
dog = Dog()
cat = Cat()
cow = Cow()

# A list of animals
animals = [dog, cat, cow]

# Loop through the animals and make them sound
print("සතුන් හඬ නගන හැටි (Polymorphic Behavior):")
for animal in animals:
    animal.makeSound() # Same method call, different output!

print("\nDuck Typing උදාහරණය:")

class Car:
    def makeSound(self):
        print("Engine starts: Vroom!")

class Bicycle:
    def makeSound(self):
        print("Bell rings: Ding-ding!")

def describe_sound(obj):
    # We don't care if it's an Animal, Car, or Bicycle,
    # as long as it has a makeSound() method.
    obj.makeSound()

print("\nDuck Typing හරහා විවිධ Object වල Sounds:")
describe_sound(Dog())
describe_sound(Car())
describe_sound(Bicycle())

මේ Code එක Run කරලා බලන්න. ඔයාට පේනවා ඇති, අපි animals කියන List එකට Dog, Cat, Cow Object දැම්මට, for loop එක ඇතුලේ අපි animal.makeSound() කියලා එකම විදියට Method එක Call කරනකොට, ඒ Object එකේ වර්ගය අනුව ඒ Method එක Execute වෙනවා. ඒක තමයි Polymorphism කියන්නේ!

Duck Typing උදාහරණයෙත් අපි describe_sound() කියන Function එකට Dog, Car, Bicycle කියන වෙනස්ම Type වල Object දුන්නා. ඒක සාර්ථකව වැඩ කළා, මොකද ඒ හැම Object එකකම makeSound() කියන Method එක තිබුණා. අපිට Class එකේ Inheritance සම්බන්ධයක් තියෙනවද නැද්ද කියලා බලන්න ඕන වුණේ නැහැ.

පොලිමෝෆිස්ම් කොයි වෙලාවටද ප්‍රයෝජනවත් වෙන්නේ?

දැන් ඔයාට හිතෙන්න පුළුවන් "අනේ මට මේකෙන් මොකක්ද වැඩේ?" කියලා. ඇත්තටම, Polymorphism කියන්නේ Software එකක් හදනකොට අපේ වැඩ ගොඩක් ලේසි කරලා, Code එක ලස්සන කරලා, නඩත්තු කරන්න පහසු කරන Tool එකක්. මෙන්න මේ වගේ අවස්ථා වලදී මේක ගොඩක් ප්‍රයෝජනවත් වෙනවා:

1. Flexibility (නම්‍යශීලී බව) සහ Extensibility (විස්තීර්ණ බව):අපේ Software System එකට අලුත් Features හෝ අලුත් Components එකතු කරන්න අවශ්‍ය වුණාම Polymorphism ගොඩක් වැදගත්. උදාහරණයක් විදියට, Payment Processing System එකක් හදනවා කියලා හිතන්න. අපිට Credit Card Payment, Bank Transfer, Mobile Wallets වගේ විවිධ Payment Methods තියෙන්න පුළුවන්. මේ හැම එකකටම processPayment() කියලා Method එකක් තියෙනවා නම්, අලුත් Payment Method එකක් ආවම, තියෙන Code එකට කිසිම හානියක් නැතුව ඒක System එකට එකතු කරන්න පුළුවන්.
2. Code Reusability (කෝඩ් නැවත භාවිත කිරීම):Polymorphism නිසා අපිට Generic Code ලියන්න පුළුවන්. ඒ කියන්නේ, අපිට Method එකක් Parameter එකක් විදියට Base Class එකක Object එකක් බලාපොරොත්තු වෙන්න පුළුවන්. එතකොට ඒ Method එකට Base Class එකෙන් Inherit වෙන ඕනෑම Child Class එකක Object එකක් යවන්න පුළුවන්. මේකෙන් Duplicate Code අඩු වෙනවා.
3. Simplifying Code (කෝඩ් සරල කිරීම):if-else if නැත්නම් switch-case වගේ Statements ගොඩක් අඩු කරගන්න පුළුවන්. අපිට විවිධ Object වලට වෙනස් විදියට වැඩ කරන්න ඕන වෙලාවට, Polymorphism පාවිච්චි කරලා ඒ Logic එක Object එක ඇතුලටම දාලා, පිටින් ඒ Logic එක පාලනය කරන Code එක සරල කරගන්න පුළුවන්.
4. Design Patterns:ගොඩක් Design Patterns වල Polymorphism කියන සංකල්පය මූලික වෙනවා. Strategy Pattern, Factory Pattern, Decorator Pattern වගේ ඒවා මේකට උදාහරණ.

හොඳම පුරුදු සහ ප්‍රායෝගික උපදෙස්

Polymorphism කියන්නේ හරිම බලගතු Tool එකක්. හැබැයි ඕනෑම බලගතු Tool එකක් වගේම, මේකත් හරි විදියට පාවිච්චි කරන්න දැනගන්න ඕන. මෙන්න පොඩි උපදෙස් ටිකක්:

1. Design for Polymorphism (Polymorphism සඳහා Design කිරීම):මුලින්ම Software Design කරනකොටම Polymorphism පාවිච්චි කරන්න පුළුවන් තැන් හඳුනාගන්න. Classes කිහිපයකට එකම ආකාරයේ Behavior එකක් (Method එකක්) තියෙනවා නම්, ඒක Polymorphic විදියට Design කරන්න පුළුවන්.
2. Use Interfaces or Abstract Classes (Interfaces හෝ Abstract Classes භාවිත කරන්න):බොහෝ Programming Languages වල Interfaces හෝ Abstract Classes කියන සංකල්ප තියෙනවා. මේවා පාවිච්චි කරලා අපිට "Contract" එකක් හදන්න පුළුවන්. ඒ කියන්නේ, මේ Interface එක Implement කරන ඕනෑම Class එකක්, අහවල් Methods අනිවාර්යයෙන්ම තියාගන්න ඕන කියලා කියන්න පුළුවන්. මේකෙන් Code එකේ Consistency එක වැඩි වෙනවා.
3. Don't Over-use (අධික ලෙස භාවිත නොකරන්න):Polymorphism හොඳයි තමයි, හැබැයි හැම තැනම පාවිච්චි කරන්න යන්න එපා. සමහර වෙලාවට සරල if-else Statement එකක් වුණත් වැඩේට ගැලපෙන්න පුළුවන්. Code එකේ Readability එක සහ Simplicity එකත් ගැන හිතන්න ඕන.
4. Clarity and Intent (පැහැදිලි බව සහ අභිප්‍රාය):Polymorphic විදියට Design කරන Code එකේ Intent එක (අරමුණ) පැහැදිලි වෙන්න ඕන. Method නම් සහ Class නම් තේරුම් ගන්න ලේසි වෙන්න ඕන.

අවසන් වචන

ඉතින්, Polymorphism කියන්නේ Object-Oriented Programming වල තියෙන ගොඩක්ම ප්‍රබල සංකල්පයක්. මේක හොඳට තේරුම් අරගෙන පාවිච්චි කරනවා නම් ඔයාට නම්‍යශීලී, නඩත්තු කරන්න පහසු, සහ ලස්සන Software Applications හදන්න පුළුවන් වෙනවා. මතක තියාගන්න, "එකම දේ, බොහෝ ආකාර". මේක පුංචි දෙයක් වගේ පෙනුණත්, Large-scale Systems වලදී මේකෙන් ලැබෙන වාසිය අති විශාලයි.

ඔයාලට මේ Post එකෙන් Polymorphism ගැන හොඳ අවබෝධයක් ලැබුණා කියලා හිතනවා. මොකද හිතෙන්නේ? ඔයාලත් Polymorphism පාවිච්චි කරලා තියෙනවද? නැත්නම් මොන වගේ Use Cases වලටද මේක පාවිච්චි කරන්න හිතෙන්නේ? ඔයාගේ අදහස් Comment Section එකේ දාන්න අමතක කරන්න එපා. අපි ඒ ගැනත් කතා කරමු.

තවත් අලුත් Concept එකක් එක්ක, ඊළඟ Post එකෙන් හම්බවෙමු!

ජය වේවා!