उपयोगकर्ता-परिभाषित तरीके (User-defined Methods)

सार्वभौमिक सत्य: जावा पूरी तरह से 'पास-बाय-वैल्यू' है:

छात्रों के बीच एक क्लासिक गलत धारणा यह है कि जावा पास-बाय-वैल्यू और पास-बाय-रेफरेंस दोनों का समर्थन करता है। वास्तव में, Java हर चीज़ को value के आधार पर पास करता है। हालाँकि, पारित मान आदिम और संदर्भ प्रकारों के बीच मौलिक रूप से भिन्न है:

शून्य स्वैप(int x, int y) {
    int अस्थायी = x; एक्स = वाई; y = तापमान;
}
// कॉलर: int a = 5, b = 10;
// स्वैप (ए, बी);
// आउटपुट: a 5 रहता है, b 10 रहता है!

void mutate(int[] arr) {
    गिरफ्तारी[0] = 999;
}
// कॉलर: int[] अंक = {10, 20};
// उत्परिवर्तित करें (संख्या);
// आउटपुट: अंक[0] 999 हो जाता है!

शुद्ध तरीके बनाम अशुद्ध तरीके:

जावा में 'रिटर्न' स्टेटमेंट को नियंत्रित करने वाले नियम:

1. नियंत्रण का तत्काल स्थानांतरण: जब रिटर्न कथन निष्पादित होता है, तो विधि तुरंत समाप्त हो जाती है, कॉल स्टैक से अपना फ्रेम हटा देती है और कॉल करने वाले को नियंत्रण लौटा देती है।
2. प्रकार संगतता: return के बाद अभिव्यक्ति का डेटा प्रकार विधि शीर्षलेख में घोषित रिटर्न प्रकार से मेल खाना चाहिए या अंतर्निहित रूप से परिवर्तनीय होना चाहिए (उदाहरण के लिए, double को वापस करने के लिए घोषित विधि में int लौटाना वैध है क्योंकि चौड़ीकरण).
3. पहुंच योग्य कोड त्रुटि: बिना शर्त रिटर्न के तुरंत बाद लिखा गया कोई भी कथन एक घातक संकलन-समय त्रुटि का कारण बनता है: "पहुंच योग्य कोड".
4. एकाधिक सशर्त रिटर्न: एक विधि में सशर्त शाखाओं के भीतर कई रिटर्न कथन शामिल हो सकते हैं (if-else), लेकिन प्रत्येक संभावित निष्पादन पथ को रिटर्न मान की गारंटी देनी चाहिए, या "लापता रिटर्न स्टेटमेंट".
के साथ संकलन विफल हो जाता है
5. शून्य विधियाँ: void रिटर्न प्रकार के साथ घोषित विधियों में, एक अभिव्यक्ति के बिना एक नंगे रिटर्न; कथन कानूनी है और शीघ्र निकास के लिए उपयोग किया जाता है।

मेथड ओवरलोडिंग के नियम:

मेथड ओवरलोडिंग एक तंत्र है जो एक वर्ग को एक ही नाम साझा करने वाली कई विधियों को घोषित करने की अनुमति देता है, बशर्ते उनकी पैरामीटर सूचियां अलग-अलग हों। यह कंपाइल-टाइम (स्टेटिक) पॉलीमोर्फिज्म का कार्यान्वयन है क्योंकि कंपाइलर तर्क सूची के आधार पर संकलन के दौरान किस विधि को लागू करना है इसका समाधान करता है।

विभिन्न विधि हस्ताक्षरों की तीन मान्य विधियाँ:

int कंप्यूट(int x) { रिटर्न x * 2; }
डबल कंप्यूट(इंट एक्स) { रिटर्न एक्स * 2.0; } //संकलन त्रुटि: विधि पहले ही परिभाषित!

मॉडल प्रोग्राम 1: अतिभारित बहुभुज आरेखण कक्षा

सार्वजनिक वर्ग अतिभारित बहुभुज {

    // 1. अतिभारित विधि: आकार n x n के अक्षर ch का एक वर्ग बनाता है
    सार्वजनिक शून्य बहुभुज(int n, char ch) {
        System.out.println("बहुभुज प्रकार 1: " + n + "x" + n + " का वर्ग '' + ch + "':" का उपयोग करके);
        के लिए (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                System.out.print(ch + " ");
            }
            System.out.println();
        }
    }

    // 2. Overloaded method: draws a rectangle of size x by y using '@'
    public void polygon(int x, int y) {
        System.out.println("Polygon Type 2: Rectangle of " + x + " rows x " + y + " columns:");
        for (int i = 1; i <= x; i++) {
            for (int j = 1; j <= y; j++) {
                System.out.print("@ ");
            }
            System.out.println();
        }
    }

    // 3. Overloaded method: draws a right-angled triangle of 3 lines using '*'
    public void polygon() {
        System.out.println("Polygon Type 3: Right-Angled Triangle of 3 rows:");
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        OverloadedPolygon obj = new OverloadedPolygon();
        obj.polygon(4, '#'); // Invokes polygon(int, char)
        System.out.println();
        obj.polygon(3, 5);   // Invokes polygon(int, int)
        System.out.println();
        obj.polygon();       // Invokes polygon()
    }
}

मॉडल प्रोग्राम 2: अतिभारित गणितीय श्रृंखला जेनरेटर

सार्वजनिक वर्ग श्रृंखलागणना {

    // 1. श्रृंखला 1: एस = 1/1 + 1/2 + 1/3 + ... + 1/एन
    सार्वजनिक डबल सीरीज(डबल एन) {
        दोगुना योग = 0.0;
        के लिए (int i = 1; i <= n; i++) {
            sum += 1.0 / i;
        }
        return sum;
    }

    // 2. Series 2: S = 1/a^2 + 4/a^5 + 7/a^8 + ... to n terms
    public double series(double a, double n) {
        double sum = 0.0;
        double numerator = 1.0;
        double power = 2.0;

        for (int i = 1; i <= n; i++) {
            sum += numerator / Math.pow(a, power);
            numerator += 3.0; // Numerator increment: 1, 4, 7, 10...
            power += 3.0;     // Exponent increment: 2, 5, 8, 11...
        }
        return sum;
    }

    public static void main(String[] args) {
        SeriesComputation sc = new SeriesComputation();
        System.out.println("Series 1 Sum (n=5): " + sc.series(5.0));
        System.out.println("Series 2 Sum (a=2, n=4): " + sc.series(2.0, 4.0));
    }
}