Java Method Overloading | පරාමිති සමග වැඩකරමු | SC Guide

ආයුබෝවන් කස්ටිය! ඉතින් කොහොමද ඔයාලට? අද අපි කතා කරන්න යන්නේ software development වලදි ගොඩක් වැදගත් වෙන, ඒ වගේම ඔයාලගේ code එක පිළිවෙලට තියාගන්න උදව් වෙන Java වල තියෙන Method Overloading කියන සංකල්පය ගැන. අපි හැමෝම code ලියද්දි එකම වැඩේට වුනත් පොඩි පොඩි වෙනස්කම් එක්ක එක එක methods හදනවා නේද? එතකොට සමහර වෙලාවට method names එක දිගට මතක තියාගන්න අමාරු වෙනවා. අන්න ඒ වගේ තැනකදි අපිට Method Overloading කියන එක ගොඩක් ප්‍රයෝජනවත් වෙනවා.

හිතන්නකෝ ඔයාලට calculator එකක් හදන්න ඕන කියලා. ඒකෙදි එකතු කරන්න (add) ඕන නම්, integer values දෙකක් වෙන්න පුළුවන්, නැත්නම් double values දෙකක් වෙන්න පුළුවන්, එහෙමත් නැත්නම් integer values තුනක් වෙන්න පුළුවන්. මේ හැම අවස්ථාවකදීම අපි add() කියලා එකම method name එක පාවිච්චි කරන්න පුළුවන් නම් කොච්චර ලේසිද? Method Overloading වලින් වෙන්නේ හරියටම ඒකයි. එකම class එක ඇතුලේ එකම නමින් methods කීපයක් හදන්න පුළුවන්, හැබැයි ඒවා parameters වලින් එකිනෙකට වෙනස් වෙන්න ඕනේ.

අද මේ article එකෙන් අපි බලමු:

• Method Overloading කියන්නේ මොකක්ද කියලා.
• Java compiler එක Overloaded methods කොහොමද අඳුරගන්නේ කියලා.
• Method Overloading වල ප්‍රයෝජන මොනවද සහ practical applications මොනවද කියලා.
• ඒ වගේම මේක පාවිච්චි කරද්දි මතක තියාගන්න ඕන හොඳම practices මොනවද කියලත්.

එහෙනම් අපි පටන් ගමු නේද?

මොකක්ද මේ Method Overloading කියන්නේ? (What is Method Overloading?)

සරලවම කිව්වොත්, Method Overloading කියන්නේ Java වලදී එකම class එක ඇතුලේ එකම නමින් methods කිහිපයක් හදන එකට. හැබැයි මේ methods එකිනෙකට වෙනස් වෙන්න ඕනේ ඒවාට යවලා තියෙන parameters වලින්. parameters කියන්නේ method එකක් ඇතුළට යවන arguments වල types සහ number. උදාහරණයක් විදිහට, ඔයාලට calculateArea() කියලා method එකක් තියෙනවා නම්, ඒක එකම නමින් හදන්න පුළුවන් වෘත්තයක (circle) වර්ගඵලය හොයන්න (එතකොට parameter එකක් - radius එක), එහෙමත් නැත්නම් හතරැස් එකක (rectangle) වර්ගඵලය හොයන්න (එතකොට parameters දෙකක් - length, width). මේකෙන් වෙන්නේ ඔයාලගේ code එක කියවන්න සහ maintain කරන්න ගොඩක් ලේසි වෙන එක.

Method Overloading වලදී, Java compiler එක method එකක් call කරද්දී, call කරන තැනින් arguments විදිහට එන values වල type සහ number අනුව, අදාල overloaded method එක තෝරාගන්නවා. මේක Compile-time Polymorphism නැත්නම් Static Polymorphism කියලත් හඳුන්වනවා. මොකද මේ method එක තෝරගන්න එක වෙන්නේ code compile වෙන වෙලාවේදී නිසා.

පහත Java code snippet එකක් බලන්න මේක කොහොමද වැඩ කරන්නේ කියලා තේරුම් ගන්න:

public class Calculator {

    // Method 1: Adds two integers
    public int add(int a, int b) {
        System.out.println("Adding two integers:");
        return a + b;
    }

    // Method 2: Adds three integers
    public int add(int a, int b, int c) {
        System.out.println("Adding three integers:");
        return a + b + c;
    }

    // Method 3: Adds two doubles
    public double add(double a, double b) {
        System.out.println("Adding two doubles:");
        return a + b;
    }

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

        // Calling Method 1
        System.out.println("Sum: " + myCalc.add(5, 10));

        // Calling Method 2
        System.out.println("Sum: " + myCalc.add(5, 10, 15));

        // Calling Method 3
        System.out.println("Sum: " + myCalc.add(5.5, 10.5));
    }
}

මේ example එකේදී, අපි add() කියන method එක තුන් පාරක් overload කරලා තියෙනවා. එකක් integers දෙකක් ගන්න, අනිත් එක integers තුනක් ගන්න, අනිත් එක doubles දෙකක් ගන්න. main method එකේදී අපි myCalc.add() කියලා call කරද්දී, Java compiler එක arguments වල type සහ number අනුව නිවැරදි add method එක තෝරාගෙන ඒක execute කරනවා. මේකෙන් වෙන්නේ code එකේ consistency එකක් තියාගන්න පුළුවන් වෙන එක.

Java කොහොමද මේවා අඳුරගන්නේ? (How Java Differentiates Overloaded Methods?)

Java compiler එක overloaded methods එකිනෙකින් වෙන් කර හඳුනාගන්නේ method signature එක අනුවයි. Method signature එක කියන්නේ method name එකයි, parameters list එකයි එකතු වුනහම. මෙතනදී මතක තියාගන්න ඕන ප්‍රධාන කරුණු කිහිපයක් තියෙනවා:

Order of Parameters (Parameters වල පිහිටීම):

parameters ගණන සහ data types සමාන වුනත්, parameters වල order එක වෙනස් නම්, ඒවත් overloaded methods විදිහට අඳුරගන්නවා. මේක එතරම් සුලභ නැති වුනත්, Java මේක valid overloading එකක් විදිහට සලකනවා.

        public void process(int a, String b) { /* ... */ }
        public void process(String a, int b) { /* ... */ }
        

මේ example එකේදී process method එකේ parameters වල order එක වෙනස් නිසා ඒවා overloaded methods.

Type of Parameters (Parameters වල data type එක):

parameters ගණන සමාන වුනත්, parameters වල data types වෙනස් නම් ඒවා overloaded methods විදිහට අඳුරගන්නවා.

        public void printValue(int value) { /* ... */ }
        public void printValue(double value) { /* ... */ }
        

මෙතනදී printValue method එක දෙපාරක් overload කරලා තියෙනවා, එකක් integer එකක් ගන්න, අනිත් එක double එකක් ගන්න.

Number of Parameters (Parameters ගණන):

මේක තමයි overload කරන්න තියෙන සරලම ක්‍රමය. method එකේ නම එකම වුනත්, එක method එකක් parameters දෙකක් ගන්නවා නම්, අනිත් එක parameters තුනක් ගන්නවා නම්, ඒවා overloaded methods විදිහට Java අඳුරගන්නවා.

        public void display(int a) { /* ... */ }
        public void display(int a, int b) { /* ... */ }
        

උඩ තියෙන example එකේදී display method එක දෙපාරක් overload කරලා තියෙනවා parameters ගණන වෙනස් කරලා.

වැදගත්ම දේ: Method Overloading වලදී method එකේ return type එක විතරක් වෙනස් කරලා methods overload කරන්න බෑ! Java compiler එක return type එකෙන් methods වෙන් කරන්නේ නෑ. මොකද method call එකක් return value එකක් ගන්නැතුවත් පාවිච්චි කරන්න පුළුවන් නිසා.

// INVALID Overloading: Only return type is different
public int getValue() { return 10; }
public double getValue() { return 10.5; } // This will cause a compile-time error

මේ වගේ අවස්ථාවක Java compiler එකට තේරෙන්නේ නෑ getValue() කියලා call කරාම, integer return කරන method එකද, double return කරන method එකද කියලා. ඒ නිසා මේක invalid overloading එකක්.

ප්‍රායෝගික භාවිතය සහ හොඳම ක්‍රම (Practical Applications and Best Practices)

Method Overloading කියන්නේ Java වලදී code clarity එක සහ reusability එක වැඩි කරන්න තියෙන සුපිරි feature එකක්. අපි බලමු මේක ප්‍රායෝගිකව කොහොමද පාවිච්චි කරන්නේ සහ මොනවද මේක පාවිච්චි කරද්දි මතක තියාගන්න ඕන දේවල් කියලා.

Return Type Is Not Part of the Signature:

අපි කලින් කතා කරා වගේ, return type එක විතරක් වෙනස් කරලා methods overload කරන්න බෑ. මේක හොඳින් මතක තියාගන්න.

Avoid Ambiguity (අනිශ්චිතභාවය වළක්වා ගැනීම):

Overloaded methods හදද්දි පරිස්සම් වෙන්න ඕනේ ambiguous calls වලින් වැලකෙන්න. Java compiler එකට method call එකක් අදාල කරගන්න overloaded method එකක් ගැන නිශ්චිතව තීරණය කරන්න බැරි වුනොත්, compiler error එකක් එනවා. උදාහරණයක් විදිහට, display(long a) සහ display(float b) කියලා methods දෙකක් තියෙද්දි display(10) කියලා call කරොත් ambiguity error එකක් එන්න පුළුවන්, මොකද 10 කියන integer එක long එකකටත්, float එකකටත් promote කරන්න පුළුවන් නිසා.

Flexibility in Handling Inputs:

Method Overloading වලින් අපිට විවිධ input data types හෝ numbers වලට අනුව method behavior එක වෙනස් කරන්න පුළුවන්. මේකෙන් code duplication අඩු වෙනවා වගේම, code එකේ flexibility එක වැඩි වෙනවා.

Code Readability and Consistency:

Method Overloading නිසා ඔයාලගේ code එක ගොඩක් readable වෙනවා. එකම වැඩේ වෙනස් input types එක්ක කරනවා නම්, එකම method name එක පාවිච්චි කරන්න පුළුවන් වීම නිසා developers ලට method එකේ නම දැක්ක ගමන් ඒකෙන් කරන වැඩේ තේරුම් ගන්න පුළුවන්. උදාහරණයක් විදිහට print() කියන method එක String, int, double වගේ විවිධ data types print කරන්න overload කරලා තිබුනොත්, ඒකෙන් වෙන්නේ print කරන එක කියලා හැමෝටම පැහැදිලියි.

Constructor Overloading:

Methods overload කරනවා වගේම, Java වල constructors වුනත් overload කරන්න පුළුවන්. මේක ගොඩක්ම ප්‍රයෝජනවත් වෙන්නේ එකම class එකේ objects විවිධ ආකාරයෙන් initialize කරන්න ඕන වුනහම.

public class Employee {
    String name;
    int id;
    double salary;

    // Constructor 1: Initialize with name and id
    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
        System.out.println("Employee created with Name and ID.");
    }

    // Constructor 2: Initialize with all details
    public Employee(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
        System.out.println("Employee created with all details.");
    }

    public static void main(String[] args) {
        Employee emp1 = new Employee("Kasun", 101);
        Employee emp2 = new Employee("Nimal", 102, 75000.00);
    }
}
        

මේ example එකේදී Employee class එකේ constructors දෙකක් තියෙනවා. එකක් name එකයි id එකයි විතරක් අරන් object එකක් හදනවා, අනිත් එක name එක, id එක සහ salary එක අරන් object එකක් හදනවා. මේක object creation වලට හොඳ flexibility එකක් දෙනවා.

මේ best practices අනුගමනය කිරීමෙන් ඔයාලට Method Overloading වල සම්පූර්ණ වාසිය ගන්න පුළුවන්, ඒ වගේම code errors අඩු කරගන්නත් පුළුවන්.

ඉතින් මොකද කියන්නේ?

හරි, එහෙනම් අද අපි Java වල තියෙන Method Overloading කියන සංකල්පය ගැන ගොඩක් දේවල් ඉගෙන ගත්තා නේද? මේක Object-Oriented Programming (OOP) වල තියෙන ගොඩක්ම බලගතු features වලින් එකක්. මේක හරියට පාවිච්චි කරනවා නම් අපේ code එක ගොඩක් clean සහ manageable කරගන්න පුළුවන්.

Method Overloading වලින් අපිට code duplication අඩු කරගෙන, code readability වැඩි කරගෙන, application එකට හොඳ flexibility එකක් දෙන්න පුළුවන්. විශේෂයෙන්ම එකම වැඩේ විවිධ data types නැත්නම් parameters ගණන් එක්ක කරන අවස්ථාවලදී මේක ගොඩක්ම ප්‍රයෝජනවත් වෙනවා.

දැන් ඔයාලට Method Overloading ගැන හොඳ අවබෝධයක් ඇති කියලා හිතනවා. පුළුවන් නම් ඔයාලත් මේක ඔයාලගේ Java projects වල පාවිච්චි කරලා බලන්න. පොඩි පොඩි examples හදලා මේ concepts එක ප්‍රායෝගිකව තේරුම් ගන්න එක ගොඩක් වැදගත්. ඒ වගේම ambiguous calls වගේ scenarios අත්හදා බලලා compiler එක කොහොමද ප්‍රතිචාර දක්වන්නේ කියලත් බලන්න.

මේ article එක ගැන ඔයාලගේ අදහස්, ප්‍රශ්න හෝ අත්දැකීම් පහළ comments section එකේ දාන්න අමතක කරන්න එපා. ඔයාලගේ අදහස් අපිට ගොඩක් වටිනවා. ඒ වගේම software development ගැන තවත් අලුත් දේවල් ඉගෙන ගන්න අපේ blog එකත් එක්කම රැඳී සිටින්න!

ඊළඟ පෝස්ට් එකෙන් හම්බවෙමු! ඔබට සුභ දවසක්!