13. జావా మెథడ్ ఓవర్‌లోడింగ్ & Varargs (Compile-time Polymorphism)

1. ఓవర్‌లోడింగ్ ఆవశ్యకత & కంపైల్-టైమ్ బైండింగ్ (Why Overloading Matters)

జావాలో మెథడ్ ఓవర్‌లోడింగ్ అనేది కోడ్ రీడబిలిటీని పదింతలు పెంచే అత్యద్భుతమైన ఫీచర్. ఉదాహరణకు జావా ప్రామాణిక లైబ్రరీలోని System.out.println() మెథడ్‌ను చూడండి. మీరు println(10) అన్నా, println("Hello") అన్నా, లేదా println(true) అన్నా అది సజావుగా ముద్రిస్తుంది. జావా డెవలపర్ ప్రతి డేటా రకానికి వేర్వేరు మెథడ్ పేర్లను గుర్తుపెట్టుకోవాల్సిన అవసరం లేకుండా PrintStream క్లాస్‌లో సుమారు 10 వేర్వేరు ఓవర్‌లోడెడ్ println() మెథడ్లను అందించడమే దీనికి కారణం.

కంపైల్-టైమ్ పాలిమార్ఫిజం (Static Binding): మీరు ప్రోగ్రామ్‌ను కంపైల్ (javac) చేస్తున్నప్పుడే, జావా కంపైలర్ మీరు పంపిన ఆర్గ్యుమెంట్ల డేటా టైప్‌లను పరిశీలించి, బైట్‌కోడ్‌లో ఏ నిర్దిష్ట మెథడ్‌ను ఇన్వోక్ చేయాలో ఖరారు చేస్తుంది. రన్‌టైమ్‌లో ఎటువంటి శోధన లేదా డైనమిక్ డిస్పాచ్ జరగదు కాబట్టి దీనివల్ల అప్లికేషన్ పనితీరులో ఎటువంటి నష్టం (Zero Runtime Overhead) ఉండదు.

2. ఓవర్‌లోడింగ్ 3 గోల్డెన్ నియమాలు (The 3 Golden Rules of Overloading)

ఒకే క్లాస్‌లో రెండు లేదా అంతకంటే ఎక్కువ మెథడ్లకు ఒకే పేరు ఉండాలంటే, వాటి పారామీటర్ల జాబితా (Parameter List) తప్పనిసరిగా క్రింది 3 మార్గాలలో కనీసం ఒకదానిలో భిన్నంగా ఉండాలి:

3. రిటర్న్ టైప్ & యాక్సెస్ మోడిఫైయర్ల పాత్ర (The Return Type Fallacy)

జావా బిగినర్లు అత్యంత ఎక్కువగా బోల్తా పడే ప్రమాదకరమైన అంశం ఇది:

public class Calculator {
    public int multiply(int a, int b) { return a * b; }
    public double multiply(int a, int b) { return (double)(a * b); } // ❌ COMPILE ERROR!
}

4. టైప్ ప్రమోషన్ & ఆటోమేటిక్ వైడనింగ్ రూల్స్ (Type Promotion in Overloading)

మీరు పంపించిన ఆర్గ్యుమెంట్ టైప్‌కు సరిగ్గా సరిపోయే (Exact Match) మెథడ్ లేనప్పుడు, జావా కంపైలర్ ఆటోమేటిక్‌గా చిన్న డేటా రకాలను పెద్ద డేటా రకాలుగా మారుస్తుంది (Automatic Type Promotion / Widening):

ఉదాహరణకు, మీరు int ఆర్గ్యుమెంట్‌ను పాస్ చేశారు, కానీ క్లాస్‌లో foo(int) లేదు. అయితే foo(long) ఉంటే, JVM ఆటోమేటిక్‌గా మీ int ను long గా ప్రమోట్ చేసి foo(long) ను విజయవంతంగా రన్ చేస్తుంది.

5. Varargs (Type... args) & హీప్ ఎరే నిర్మాణం (Variable Arguments Internals)

Java 5 కి ముందు, ఒక మెథడ్‌కు అనిశ్చిత సంఖ్యలో (Arbitrary Number) ఆర్గ్యుమెంట్లను పంపించాలంటే డెవలపర్ తప్పనిసరిగా మాన్యువల్‌గా ఒక ఎరేను సృష్టించి పంపించాల్సి వచ్చేది (ఉదా: printItems(new String[]{"A", "B"})).

దీనికి పరిష్కారంగా Varargs (Variable Arguments) ఫీచర్ ప్రవేశపెట్టబడింది. డేటా టైప్ తర్వాత మూడు చుక్కలు (Type... varName) ఉంచడం ద్వారా దీన్ని వాడతాం.

అంతర్గత మెకానిజం: మీరు logMessages("Err1", "Err2", "Err3"); అని కాల్ చేసినప్పుడు, జావా కంపైలర్ అంతర్గతంగా logMessages(new String[]{"Err1", "Err2", "Err3"}); గా మారుస్తుంది. మీరు సున్నా ఆర్గ్యుమెంట్లు పంపితే (logMessages()), ఖాళీ ఎరే new String[0] హీప్‌లో ఏర్పడుతుంది!

6. Varargs నియమాలు: లాస్ట్ పారామీటర్ రూల్ (The Strict Syntactic Rules)

Varargs తో పనిచేసేటప్పుడు జావా కంపైలర్ విధించిన రెండు కఠినమైన నియమాలను గుర్తుంచుకోవాలి:

• నియమం 1 (Last Parameter Rule): మెథడ్ పారామీటర్ల జాబితాలో Varargs ఎల్లప్పుడూ చివరి పారామీటర్‌గా మాత్రమే ఉండాలి! (ఉదా: void test(int x, String... names) చెల్లుబాటు అవుతుంది; కానీ void test(String... names, int x) కంపైలేషన్ ఎర్రర్).
• నియమం 2 (Single Varargs Rule): ఒక మెథడ్‌లో కేవలం ఒకే ఒక్క Varargs పారామీటర్ మాత్రమే ఉండాలి. ఒకే మెథడ్‌లో void test(int... a, String... b) రాయడం చట్టవిరుద్ధం.

7. Widening vs Autoboxing vs Varargs ప్రాధాన్యత (Compiler Resolution Priority)

ఒక మెథడ్ కాల్‌ను పరిష్కరించేటప్పుడు జావా కంపైలర్ అత్యంత ఖచ్చితమైన ప్రాధాన్యతా క్రమాన్ని (Resolution Hierarchy) అనుసరిస్తుంది:

ముఖ్యమైన గమనిక: జావా కంపైలర్ బ్యాక్‌వర్డ్ అనుకూలత (Backward Compatibility) కోసం రూపొందించబడింది. Widening అనేది Java 1.0 నాటిది, Autoboxing మరియు Varargs అనేవి Java 5 లో వచ్చాయి. అందువల్ల పాతకాలపు Widening ఎల్లప్పుడూ Autoboxing మరియు Varargs కంటే ముందు గెలుస్తుంది!

8. Ambiguity ట్రాప్స్ & కంపైలర్ ఎర్రర్స్ (The Ambiguous Method Pitfall)

ఓవర్‌లోడింగ్ మరియు Varargs ను కలిపి వాడేటప్పుడు అత్యంత జాగ్రత్తగా ఉండాలి. క్రింది కోడ్ చూడండి:

ఖాళీ ఆర్గ్యుమెంట్‌తో పిలిచినప్పుడు, అది int[] కావాలో లేదా String[] కావాలో కంపైలర్ తేల్చుకోలేక క్రాష్ అవుతుంది. ఇటువంటి ఆంబిగ్యుటీలను నివారించడానికి Varargs మెథడ్లను విచక్షణారహితంగా ఓవర్‌లోడ్ చేయకూడదు.

9. డెమో 1: Widening vs Autoboxing vs Varargs ప్రయారిటీ (Priority Showdown)

జావా కంపైలర్ యొక్క రిసొల్యూషన్ క్రమాన్ని కళ్లారా ధృవీకరించే ప్రాక్టికల్ డెమో ఇది:

public class OverloadingResolutionPriorityDemo {

    // Overloaded candidate methods
    public static void process(long val) {
        System.out.println("  -> [Winner: Widening] matched process(long): " + val);
    }

    public static void process(Integer val) {
        System.out.println("  -> [Winner: Autoboxing] matched process(Integer): " + val);
    }

    public static void process(int... vals) {
        System.out.println("  -> [Winner: Varargs] matched process(int...): count = " + vals.length);
    }

    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("⚖️ COMPILER OVERLOADING RESOLUTION PRIORITY TEST");
        System.out.println("=================================================
");

        int testValue = 42;

        System.out.println("Calling process(int 42) with long, Integer, and int... available:");
        process(testValue);

        System.out.println("
తీర్పు:");
        System.out.println("1. Widening (long) beats Autoboxing (Integer) & Varargs (int...)!");
        System.out.println("2. Varargs ఎల్లప్పుడూ ఆఖరి ఎంపికగా మాత్రమే పరిగణించబడుతుంది.");
        System.out.println("=================================================");
    }
}

=================================================
⚖️ COMPILER OVERLOADING RESOLUTION PRIORITY TEST
=================================================

Calling process(int 42) with long, Integer, and int... available:
  -> [Winner: Widening] matched process(long): 42

తీర్పు:
1. Widening (long) beats Autoboxing (Integer) & Varargs (int...)!
2. Varargs ఎల్లప్పుడూ ఆఖరి ఎంపికగా మాత్రమే పరిగణించబడుతుంది.
=================================================

10. డెమో 2: ఫ్లెక్సిబుల్ Varargs మ్యాథ్ కాలిక్యులేటర్ (Flexible Math Calculator)

ఒకటి లేదా అంతకంటే ఎక్కువ పారామీటర్లను తప్పనిసరి చేస్తూ, మిగిలిన ఎన్ని సంఖ్యలనైనా స్వీకరించే ఫ్లెక్సిబుల్ మ్యాథ్ కాలిక్యులేటర్‌ను ఎలా డిజైన్ చేయాలో పరిశీలిద్దాం:

public class FlexibleVarargsCalculator {

    // Overloaded sum methods
    public static int sum(int a, int b) {
        return a + b;
    }

    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

    // Varargs sum for any quantity (4 or more, or dynamic collections)
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    // Best Practice: At least one parameter is strictly mandatory
    public static double average(double first, double... rest) {
        double total = first;
        for (double val : rest) {
            total += val;
        }
        return total / (rest.length + 1);
    }

    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("🧮 FLEXIBLE OVERLOADED & VARARGS CALCULATOR");
        System.out.println("=================================================
");

        System.out.println("1. Two parameters:   sum(10, 20)             = " + sum(10, 20));
        System.out.println("2. Three parameters: sum(10, 20, 30)         = " + sum(10, 20, 30));
        System.out.println("3. Varargs (5 nums): sum(5, 10, 15, 20, 25)  = " + sum(5, 10, 15, 20, 25));
        System.out.println("4. Varargs (0 nums): sum()                   = " + sum());

        System.out.println("
5. Mandatory First Arg Average:");
        System.out.printf("   average(100.0)                     = %.2f%n", average(100.0));
        System.out.printf("   average(80.0, 90.0, 95.0, 85.0)     = %.2f%n", average(80.0, 90.0, 95.0, 85.0));

        System.out.println("=================================================");
    }
}

=================================================
🧮 FLEXIBLE OVERLOADED & VARARGS CALCULATOR
=================================================

1. Two parameters:   sum(10, 20)             = 30
2. Three parameters: sum(10, 20, 30)         = 60
3. Varargs (5 nums): sum(5, 10, 15, 20, 25)  = 75
4. Varargs (0 nums): sum()                   = 0

5. Mandatory First Arg Average:
   average(100.0)                     = 100.00
   average(80.0, 90.0, 95.0, 85.0)     = 87.50
=================================================

11. Capstone ప్రాజెక్ట్: మల్టీ-ఛానల్ క్లౌడ్ అలర్ట్ డిస్పాచర్ ఇంజిన్

ఈ అధ్యాయంలో నేర్చుకున్న అన్ని కాన్సెప్టులను (మెథడ్ ఓవర్‌లోడింగ్, Varargs, కంపైల్-టైమ్ సేఫ్టీ, స్ట్రింగ్ ఫార్మాటింగ్) సమగ్రంగా మేళవిస్తూ ఒక ఎంటర్‌ప్రైజ్ స్థాయి Multi-Channel Cloud Alert & Incident Dispatcher ను నిర్మిద్దాం:

public class CloudNotificationDispatcherEngine {

    public enum Priority { LOW, MEDIUM, HIGH, CRITICAL }

    // Overloaded Dispatch Methods

    // 1. Single SMS Alert
    public static void sendAlert(String phoneNumber, String message) {
        System.out.printf("📱 [SMS DISPATCH] To: %s | Message: %s%n", phoneNumber, message);
    }

    // 2. Email with Subject and Priority
    public static void sendAlert(String email, String subject, Priority priority, String message) {
        System.out.printf("📧 [EMAIL DISPATCH] To: %-18s | Priority: %-8s | Subj: %-15s | Body: %s%n",
                email, priority, subject, message);
    }

    // 3. Multi-Channel Broadcast via Varargs
    public static void sendAlert(Priority priority, String message, String... targetChannels) {
        System.out.printf("%n📢 [BROADCAST ALERT - %s] Message: '%s'%n", priority, message);
        System.out.println("   Active Target Nodes (" + targetChannels.length + "):");
        for (String channel : targetChannels) {
            System.out.println("    └─► Dispatched to channel: " + channel);
        }
    }

    public static void main(String[] args) {
        System.out.println("=================================================");
        System.out.println("🚨 ENTERPRISE CLOUD MULTI-CHANNEL DISPATCHER");
        System.out.println("=================================================
");

        // Use case 1: Quick SMS
        sendAlert("+91-9848012345", "OTP for login: 928410. Valid for 5 mins.");

        // Use case 2: Rich Email
        sendAlert("balaji@company.com", "DB High Memory", Priority.HIGH, "PostgreSQL RAM exceeded 88% threshold.");

        // Use case 3: Varargs Incident Broadcast to multiple internal channels
        sendAlert(
            Priority.CRITICAL,
            "Service Outage: PaymentGateway-v2 returned 503 Service Unavailable",
            "#slack-incident-war-room",
            "pagerduty:on-call-dev",
            "webhook:https://status.company.com/api/v1/update",
            "email:executives@company.com"
        );

        System.out.println("
=================================================");
        System.out.println("✅ All notification streams dispatched successfully!");
        System.out.println("=================================================");
    }
}

=================================================
🚨 ENTERPRISE CLOUD MULTI-CHANNEL DISPATCHER
=================================================

📱 [SMS DISPATCH] To: +91-9848012345 | Message: OTP for login: 928410. Valid for 5 mins.
📧 [EMAIL DISPATCH] To: balaji@company.com  | Priority: HIGH     | Subj: DB High Memory  | Body: PostgreSQL RAM exceeded 88% threshold.

📢 [BROADCAST ALERT - CRITICAL] Message: 'Service Outage: PaymentGateway-v2 returned 503 Service Unavailable'
   Active Target Nodes (4):
    └─► Dispatched to channel: #slack-incident-war-room
    └─► Dispatched to channel: pagerduty:on-call-dev
    └─► Dispatched to channel: webhook:https://status.company.com/api/v1/update
    └─► Dispatched to channel: email:executives@company.com

=================================================
✅ All notification streams dispatched successfully!
=================================================

12. ప్రొడక్షన్ పిట్‌ఫాల్స్, బెస్ట్ ప్రాక్టీసెస్ & 5 క్విజ్‌లు (Best Practices & Quizzes)

🚫 ప్రొడక్షన్‌లో నివారించాల్సిన 4 ఘోరమైన తప్పులు (Production Pitfalls):

1. కేవలం రిటర్న్ టైప్ మార్చి ఓవర్‌లోడ్ చేయాలని ప్రయత్నించడం: ఇది కంపైలేషన్ ఎర్రర్‌కు దారితీస్తుంది.
2. ప్రాచీనమైన Widening మరియు Autoboxing ను ఒకేసారి ఆశించడం: జావా int ను ఒకే స్టెప్‌లో Long (Widening + Autoboxing) గా మార్చదు! int ➔ long సాధ్యమే, లేదా int ➔ Integer సాధ్యమే, కానీ int ➔ Long కంపైలేషన్ ఎర్రర్ అవుతుంది.
3. Varargs మెథడ్లను విపరీతంగా ఓవర్‌లోడ్ చేయడం: ఇది కాలర్ల వద్ద అంతుచిక్కని ambiguous method call ఎర్రర్‌లను తెచ్చిపెడుతుంది.
4. లూపులలో ప్రతిసారీ Varargs ను పిలవడం: లూప్‌లో వేలాది సార్లు Varargs పిలిస్తే ప్రతిసారీ కొత్త తాత్కాలిక ఎరే హీప్‌లో ఏర్పడి GC పై భారం పడుతుంది. భారీ లూపులకు స్పష్టమైన ఎరే లేదా కలెక్షన్లను ముందే కేటాయించండి.

✨ ప్రొడక్షన్ గోల్డెన్ రూల్స్ (Golden Rules):

🧠 మీ అవగాహనను పరీక్షించుకోండి (5 Interactive Quizzes):