Java Polymorphism: එකම නමකින් විවිධ වැඩ ගන්න හැටි!

කොහොමද යාලුවනේ? Software Ceylon Tech Blog එකට ඔයාලව සාදරයෙන් පිළිගන්නවා! අද අපි කතා කරන්න යන්නේ Java වල ඉතාම වැදගත් සහ දක්ෂ programer කෙනෙක් වෙන්න අත්‍යවශ්‍ය සංකල්පයක් ගැන – ඒ තමයි Polymorphism. මේක අහන්න ටිකක් අමාරු වචනයක් වුනාට, තේරුම් ගන්න හරිම සරලයි. තේරුම් ගත්තොත් ඔයාලගේ coding ජීවිතේට ලොකු පහසුවක් වෙයි. Java වල Object-Oriented Programming (OOP) වල මුල්ගල් 4න් එකක් තමයි මේ Polymorphism කියන්නේ. අනිත් ඒවා තමයි Encapsulation, Inheritance, Abstraction.

Polymorphism කියන්නේ 'එකම නමකින් විවිධ වැඩ කරන්න පුළුවන්කම' කියන එක සරලවම. හිතන්න, අපේ ගෙදර තාත්තා කෙනෙක්, ඒ වගේම රැකියාවක නිරත වෙන කෙනෙක්, ඒ වගේම යාළුවෙක් වෙන්න පුළුවන්. එකම පුද්ගලයා, විවිධ තැන්වලදී විවිධ විදිහට හැසිරෙනවා නේද? Polymorphism කියන්නේ හරියටම ඒ වගේමයි. එකම method එකකට, එකම class එකකට හෝ එකම object එකකට විවිධ හැසිරීම් (behaviors) තියෙන්න පුළුවන්.

අපි මේ ගැන තවත් සරලව, Sri Lankan accent එකට ගැලපෙන විදිහට, code උදාහරණ එක්ක බලමු. මොකද, theory විතරක් ඉගෙනගෙන වැඩක් නෑනේ, practical කරන්නත් එපැයි!

Polymorphism කියන්නේ මොකක්ද? (සරලව තේරුම් ගනිමු!)

Polymorphism කියන වචනේ එන්නේ ග්‍රීක් භාෂාවෙන්. 'Poly' කියන්නේ 'බොහෝ' (many) කියන එක, 'morph' කියන්නේ 'හැඩය' (forms) කියන එක. ඒ කියන්නේ, 'බොහෝ හැඩයන්' (many forms). Java වලදී මේකෙන් කියවෙන්නේ, එකම interface එකක් හරහා, විවිධ ආකාරයේ Objects (හෝ methods) එක්ක වැඩ කරන්න පුළුවන්කම.

Polymorphism ප්‍රධාන වශයෙන් ආකාර දෙකකින් අපිට හමුවෙනවා:

1. Compile-time Polymorphism (Static Polymorphism): මේක තීරණය වෙන්නේ program එක compile වෙන වෙලාවේදී. Method Overloading මේකට හොඳම උදාහරණයක්.
2. Runtime Polymorphism (Dynamic Polymorphism): මේක තීරණය වෙන්නේ program එක run වෙන වෙලාවේදී. Method Overriding මේකට හොඳම උදාහරණයක්.

අපි දැන් මේ දෙකම, ඒවායේ තියෙන වෙනස්කම් එක්ක, හොඳින් තේරුම් ගනිමු.

Compile-time Polymorphism: Method Overloading

Method Overloading කියන්නේ එකම class එකක් ඇතුලේ, එකම නම තියෙන method කිහිපයක් හදන එක. හැබැයි, මේ method වල parameters (ආදාන අගයන්) වෙනස් වෙන්න ඕනේ. ඒ කියන්නේ parameters වල ගණන, වර්ගය (data type), හෝ පිළිවෙල (order) වෙනස් වෙන්න ඕනේ. Java compiler එක program එක compile කරන වෙලාවේදී, අපි call කරන method එකට ගැලපෙන parameters තියෙන method එක තෝරනවා. ඒ නිසා තමයි මේකට Compile-time Polymorphism කියන්නේ.

සරල උදාහරණයක් බලමු. අපි Calculator කියන class එකක් හදමු, ඒකේ numbers දෙකක්, තුනක්, හෝ floating point numbers එකතු කරන add කියන method එකක් තියෙනවා කියලා හිතමු.

උදාහරණය: Method Overloading

class Calculator {
    // එකම නමේ method එකක්, parameters දෙකක් එක්ක
    public int add(int a, int b) {
        System.out.println("Integers දෙකක් එකතු කරයි.");
        return a + b;
    }

    // එකම නමේ method එකක්, parameters තුනක් එක්ක
    public int add(int a, int b, int c) {
        System.out.println("Integers තුනක් එකතු කරයි.");
        return a + b + c;
    }

    // එකම නමේ method එකක්, වෙනත් data type (double) parameters එක්ක
    public double add(double a, double b) {
        System.out.println("Doubles දෙකක් එකතු කරයි.");
        return a + b;
    }
}

public class OverloadingDemo {
    public static void main(String[] args) {
        Calculator myCalc = new Calculator();

        // පළවෙනි add method එක call වෙනවා
        System.out.println("Sum of 5, 10: " + myCalc.add(5, 10));

        // දෙවෙනි add method එක call වෙනවා
        System.out.println("Sum of 5, 10, 15: " + myCalc.add(5, 10, 15));

        // තුන්වෙනි add method එක call වෙනවා
        System.out.println("Sum of 5.5, 10.5: " + myCalc.add(5.5, 10.5));
    }
}

මේ උදාහරණයේදී, Calculator class එකේ add කියන method එක පාරවල් තුනක් define කරලා තියෙනවා. හැබැයි, හැම method එකකම parameters වෙනස්. අපි main method එකෙන් add call කරනකොට, compiler එක (program එක run වෙන්න කලින්), අපි දීලා තියෙන parameters වලට ගැලපෙන method එක මොකක්ද කියලා තීරණය කරනවා. මේක තමයි Method Overloading කියන්නේ. මේකෙන් code එක කියවන්න ලේසියි, එකම වර්ගයේ වැඩ වලට එකම නමක් පාවිච්චි කරන්න පුළුවන් නිසා.

Runtime Polymorphism: Method Overriding

Method Overriding කියන්නේ Inheritance (උරුමය) එක්ක වැඩ කරන දෙයක්. මේකේදී superclass (parent class) එකේ තියෙන method එකක්, subclass (child class) එකේදී වෙනස් විදිහට නැවත හදනවා. ඒ කියන්නේ, method එකේ නම, return type එක, සහ parameters සුපර්ක්ලාස් එකේ වගේමයි, හැබැයි subclass එකේදී ඒ method එක ඇතුලේ කරන වැඩේ (implementation) වෙනස් වෙනවා.

මේක Runtime Polymorphism වෙන්නේ, අපි Object එකක් create කරනකොට (program එක run වෙන වෙලාවේදී), JVM (Java Virtual Machine) එක තමයි තීරණය කරන්නේ superclass එකේ method එකද, subclass එකේ method එකද call කරන්න ඕනේ කියලා. මේකට Dynamic Method Dispatch කියලත් කියනවා.

උදාහරණය: Method Overriding

අපි Animal කියන superclass එකක් හදමු. ඒකේ makeSound() කියලා method එකක් තියෙනවා. ඊට පස්සේ, Dog සහ Cat කියන subclasses දෙකක් හදලා, ඒවයේ makeSound() method එක override කරමු.

class Animal {
    public void makeSound() {
        System.out.println("සතෙක් ශබ්දයක් නිකුත් කරයි.");
    }
}

class Dog extends Animal {
    @Override // මේකෙන් කියවෙන්නේ මේ method එක override කරනවා කියලා.
    public void makeSound() {
        System.out.println("බල්ලා බුරයි: Bow-wow!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("බළලා මියුව් කියයි: Meow!");
    }
}

public class OverridingDemo {
    public static void main(String[] args) {
        Animal myAnimal1 = new Animal();
        Animal myAnimal2 = new Dog(); // Upcasting: Dog object එක Animal reference එකකින් අල්ලගෙන.
        Animal myAnimal3 = new Cat(); // Upcasting: Cat object එක Animal reference එකකින් අල්ලගෙන.

        System.out.print("myAnimal1 කියන්නේ: ");
        myAnimal1.makeSound(); // Animal class එකේ makeSound() call වෙනවා

        System.out.print("myAnimal2 කියන්නේ: ");
        myAnimal2.makeSound(); // Dog class එකේ makeSound() call වෙනවා (Runtime Polymorphism)

        System.out.print("myAnimal3 කියන්නේ: ");
        myAnimal3.makeSound(); // Cat class එකේ makeSound() call වෙනවා (Runtime Polymorphism)

        // instanceof operator එකෙන් object එකේ real type එක බලන්න පුළුවන්
        if (myAnimal2 instanceof Dog) {
            System.out.println("myAnimal2 කියන්නේ Dog වර්ගයේ object එකක්.");
        }
    }
}

මේ උදාහරණයේදී, myAnimal2 සහ myAnimal3 කියන reference variables දෙකම Animal වර්ගයේ වුණත්, ඒවට assign කරලා තියෙන්නේ Dog සහ Cat වර්ගයේ objects. අපි makeSound() method එක call කරනකොට, JVM එක run වෙන වෙලාවේදී තීරණය කරනවා ඇත්තටම තියෙන object එකේ (Dog or Cat) makeSound() method එක call කරන්නද කියලා. මේකට තමයි Runtime Polymorphism කියන්නේ. මේකෙන් අපිට ගොඩක් flexibility එකක් ලැබෙනවා. උදාහරණයක් විදිහට, එකම Animal reference එකක් පාවිච්චි කරලා, විවිධ සත්ත්ව Objects වලට ඒ ඒ සත්ත්වයාට ආවේණික විදිහට ශබ්ද නිකුත් කරන්න පුළුවන් වෙයි.

@Override annotation එකක් පාවිච්චි කිරීම හොඳ practice එකක්. ඒකෙන් compiler එකට කියනවා මේ method එක superclass එකේ method එකක් override කරනවා කියලා. මේකෙන් spelling වැරදි වගේ දේවල් වෙලා, method එක override නොවී, අලුත් method එකක් හැදෙන එක වළක්වාගන්න පුළුවන්.

Polymorphism වල වාසි මොනවද?

Polymorphism සංකල්පය Java programming වලදී අපිට ගොඩක් වාසි අරගෙන දෙනවා. ඒ වාසි ටිකක් අපි බලමු:

Better Readability (කියවීමේ පහසුව)

එකම ආකාරයේ operations වලට එකම method නමක් පාවිච්චි කරන එකෙන් code එක කියවන්න සහ තේරුම් ගන්න ලේසියි.

Maintainability (පහසුවෙන් නඩත්තු කිරීමේ හැකියාව)

Code එක organized විදිහට තියෙන නිසා, වැරදි හදන එක, වෙනස්කම් කරන එක ගොඩක් පහසු වෙනවා. එකම method නමක් නිසා, මොන method එක call වෙන්නේද කියලා තේරුම් ගන්නත් ලේසියි.

Flexibility and Extensibility (නම්‍යශීලීත්වය සහ පුළුල් කිරීමේ හැකියාව)

Polymorphism නිසා code එකට අලුත් functionality එකතු කරන එක ලේසියි. උදාහරණයක් විදිහට, අපේ Animal උදාහරණයේදී, අපිට අලුත් සත්ත්ව වර්ගයක් (බලු, බළලු වගේ) එකතු කරන්න පුළුවන්, Animal superclass එකේ makeSound() method එක override කරලා. Main program එකේ තියෙන code එක වෙනස් කරන්න ඕනේ නෑ. මේකෙන් අපේ software එක future එකටත් පහසුවෙන් adapt කරන්න පුළුවන්.

Code Reusability (කේත නැවත භාවිතා කිරීමේ හැකියාව)

Method overloading මගින්, එකම method නමක් විවිධ tasks සඳහා භාවිතා කරන්න පුළුවන්. ඒ වගේම method overriding මගින්, parent class එකේ functionality එක child class එකේදී වෙනස් කරලා පාවිච්චි කරන්න පුළුවන්. මේකෙන් අලුතෙන් code ලියන එක අඩු වෙනවා.

අවසාන වශයෙන්: Polymorphism වල බලය

ඉතින් යාලුවනේ, Polymorphism කියන්නේ Java Programming වලදී ඔයාලට අනිවාර්යෙන්ම දැනගන්න ඕනේම දෙයක්. මේකෙන් ඔයාලට Clean, Efficient, සහ Maintainable code ලියන්න පුළුවන්කම ලැබෙනවා. විශේෂයෙන්ම ලොකු projects කරනකොට Polymorphism වල වටිනාකම තවත් වැඩි වෙනවා.

අපි අද කතා කරපු Method Overloading සහ Method Overriding කියන Concepts දෙක හොඳටම තේරුම් ගියා කියලා හිතනවා. මතක තියාගන්න, coding කියන්නේ කරලාම ඉගෙනගන්න ඕනේ දෙයක්. මේ උදාහරණ ටික ඔයාලගේ computer එකේ run කරලා බලන්න, වෙනස්කම් කරලා බලන්න, experiment කරන්න. එතකොට තව හොඳට තේරෙයි.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න තියෙනවා නම් පහළින් comment section එකේ දාන්න. අපි ඒවට උත්තර දෙන්න ලෑස්තියි. ඒ වගේම මේ වගේ තවත් වැදගත් ලිපි බලාපොරොත්තු වෙන්න Software Ceylon Tech Blog එකත් එක්කම රැඳී සිටින්න. ආයෙත් මේ වගේ ලිපියකින් හමුවෙමු!

ජය වේවා!