जावा में तरीके

फिर से हैलो! पिछले पाठ में हम कक्षाओं और निर्माणकर्ताओं से परिचित हुए, और सीखा कि अपना खुद का निर्माण कैसे करें। आज हम जावा मेथड्स से बेहतर परिचित होंगे, जो कक्षाओं का एक अनिवार्य हिस्सा है। जावा में मेथड्स कमांड का एक सेट है जो आपको एक प्रोग्राम में एक विशिष्ट ऑपरेशन करने की अनुमति देता है। दूसरे शब्दों में, एक विधि एक कार्य है; कुछ ऐसा जो आपकी कक्षा करने में सक्षम है। अन्य प्रोग्रामिंग भाषाओं में, विधियों को अक्सर "फ़ंक्शन" कहा जाता है, लेकिन जावा में "विधि" शब्द अधिक सामान्य है। :) अगर आपको याद हो, तो पिछले पाठ में हमने बिल्ली वर्ग के लिए आसान तरीके बनाए थे, ताकि हमारी बिल्लियाँ म्याऊ बोल सकें और कूद सकें:

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Pounce!");
    }

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        smudge.sayMeow();
        smudge.jump();
    }
}

SayMeow () और जंप () हमारी कक्षा के तरीके हैं। और इन विधियों को चलाने के परिणामस्वरूप निम्न कंसोल आउटपुट होता है:

Meow!
Pounce!

हमारे तरीके काफी सरल हैं: वे केवल टेक्स्ट को कंसोल पर आउटपुट करते हैं। लेकिन जावा में, विधियों का एक महत्वपूर्ण कार्य है: वे किसी वस्तु के डेटा पर क्रिया करते हैं। वे वस्तु के डेटा को बदलते हैं, इसे रूपांतरित करते हैं, इसे प्रदर्शित करते हैं और इसके साथ अन्य काम करते हैं। हमारे मौजूदा तरीके कैट ऑब्जेक्ट के डेटा के साथ कुछ नहीं करते हैं । आइए एक और उदाहरण उदाहरण देखें:

public class Truck {

    int length;
    int width;
    int height;
    int weight;

    public int getVolume() {
        int volume = length * width * height;
        return volume;
    }
}

उदाहरण के लिए, यहां हमारे पास ट्रक का प्रतिनिधित्व करने वाला एक वर्ग है । अर्ध ट्रक की लंबाई, चौड़ाई, ऊंचाई और वजन होता है (जिसकी हमें बाद में आवश्यकता होगी)। GetVolume () विधि में , हम गणना करते हैं, हमारे ऑब्जेक्ट के डेटा को उसकी मात्रा का प्रतिनिधित्व करने वाली संख्या में परिवर्तित करते हैं (हम लंबाई, चौड़ाई और ऊंचाई को गुणा करते हैं)। यह संख्या विधि का परिणाम होगी। ध्यान दें कि विधि की घोषणा public int getVolume के रूप में लिखी गई है । इसका मतलब है कि इस विधि को एक int वापस करना होगा । हमने मेथड के रिटर्न वैल्यू की गणना की, और अब हमें इसे उस प्रोग्राम में वापस करना होगा जो हमारी मेथड कहलाता है। Java में किसी मेथड के रिजल्ट को वापस करने के लिए, हम कीवर्ड रिटर्न का उपयोग करते हैं। वापसी की मात्रा;

जावा विधि पैरामीटर

हम किसी विधि को कॉल करते समय "तर्क" नामक मान पास कर सकते हैं। एक विधि की घोषणा में वेरिएबल्स की एक सूची शामिल होती है जो हमें वेरिएबल्स के प्रकार और क्रम को बताती है जिसे विधि स्वीकार कर सकती है। इस सूची को "विधि पैरामीटर" कहा जाता है। हमारे ट्रक वर्ग की getVolume () विधि वर्तमान में किसी भी पैरामीटर को परिभाषित नहीं करती है, तो आइए अपने ट्रक उदाहरण को विस्तारित करने का प्रयास करें। ब्रिजऑफिसर नामक एक नया वर्ग बनाएँ । यह एक पुल पर ड्यूटी पर तैनात एक पुलिस अधिकारी है, जो सभी गुजरने वाले ट्रकों की जांच करता है कि उनका भार अनुमत वजन से अधिक है या नहीं।

public class BridgeOfficer {

    int maxWeight;

    public BridgeOfficer(int normalWeight) {
        this.maxWeight = normalWeight;
    }

    public boolean checkTruck(Truck truck) {
        if (truck.weight > maxWeight) {
            return false;
        } else {
            return true;
        }
    }
}

चेकट्रक विधि एक तर्क, एक ट्रक वस्तु को स्वीकार करती है, और यह निर्धारित करती है कि अधिकारी ट्रक को पुल पर अनुमति देगा या नहीं। विधि के अंदर, तर्क काफी सरल है: यदि ट्रक का वजन अधिकतम अनुमत से अधिक है, तो विधि गलत हो जाती है । इसे दूसरी सड़क ढूंढनी होगी :( यदि वजन अधिकतम से कम या उसके बराबर है, तो यह गुजर सकता है, और विधि सही हो जाती है. यदि आप अभी तक "वापसी" या "विधि रिटर्न वैल्यू" वाक्यांशों को पूरी तरह से नहीं समझते हैं, तो आइए प्रोग्रामिंग से विराम लें और वास्तविक जीवन से एक सरल उदाहरण का उपयोग करके उन पर विचार करें। :) मान लीजिए कि आप बीमार हो जाते हैं और कुछ दिनों के लिए काम से घर पर रहते हैं। आप अपने डॉक्टर के नोट के साथ लेखा विभाग में जाते हैं, क्योंकि बीमार छुट्टी का भुगतान करना होता है। यदि हम इस स्थिति की विधियों से तुलना करते हैं, तो लेखाकार के पास एक paySickLeave () हैतरीका। आप इस पद्धति के तर्क के रूप में एक डॉक्टर का नोट पास करते हैं (इसके बिना, विधि काम नहीं करेगी और आपको भुगतान नहीं मिलेगा!)। फिर आपके नोट का उपयोग करके विधि के अंदर आवश्यक गणना की जाती है (लेखाकार इसका उपयोग यह गणना करने के लिए करता है कि कंपनी को आपको कितना भुगतान करना चाहिए), और आपके काम का परिणाम (धन की राशि) आपको वापस कर दिया जाता है। हमारा कार्यक्रम इसी तरह काम करता है। यह एक विधि को कॉल करता है, इसे डेटा पास करता है और अंत में एक परिणाम प्राप्त करता है। यहां हमारे ब्रिजऑफिसर प्रोग्राम की मुख्य () विधि है:

public static void main(String[] args) {
    Truck first = new Truck();
    first.weight = 10000;
    Truck second = new Truck();
    second.weight = 20000;

    BridgeOfficer officer = new BridgeOfficer(15000);
    System.out.println("Truck 1! Can I go, officer?");
    boolean canFirstTruckGo = officer.checkTruck(first);
    System.out.println(canFirstTruckGo);

    System.out.println();

    System.out.println("Truck 2! And can I?");
    boolean canSecondTruckGo = officer.checkTruck(second);
    System.out.println(canSecondTruckGo);
}

हम 10,000 और 20,000 के भार वाले दो ट्रक बनाते हैं। और जिस पुल पर अधिकारी काम करता है उसका वजन अधिकतम 15,000 होता है। यह प्रोग्राम ऑफिसर.चेकट्रक(फर्स्ट) मेथड को कॉल करता है। विधि सब कुछ की गणना करती है और फिर सत्य लौटाती है , जिसे प्रोग्राम तब बूलियन चर canFirstTruckGo में सहेजता है । अब आप इसके साथ जो चाहें कर सकते हैं (ठीक वैसे ही जैसे आप अकाउंटेंट द्वारा दिए गए पैसों से कर सकते हैं)। दिन के अंत में, कोड

boolean canFirstTruckGo = officer.checkTruck(first);

उबल जाता है

boolean canFirstTruckGo =  true;

यहाँ एक बहुत ही महत्वपूर्ण बिंदु है: रिटर्न स्टेटमेंट न केवल विधि का रिटर्न मान लौटाता है, बल्कि यह विधि को चलने से भी रोकता है! रिटर्न स्टेटमेंट के बाद आने वाला कोई भी कोड निष्पादित नहीं किया जाएगा!

public boolean checkTruck(Truck truck) {

    if (truck.weight > maxWeight) {
        return false;
        System.out.println("Turn around, you're overweight!");
    } else {
        return true;
        System.out.println("Everything looks good, go ahead!");
    }
}

अधिकारी की टिप्पणी प्रदर्शित नहीं की जाएगी, क्योंकि विधि पहले ही एक परिणाम लौटा चुकी है और समाप्त हो चुकी है! कार्यक्रम उस स्थान पर लौटता है जहां विधि को बुलाया गया था। आपको इसके लिए देखने की ज़रूरत नहीं है: जब आप रिटर्न स्टेटमेंट के बाद कोड लिखने का प्रयास करते हैं तो जावा कंपाइलर त्रुटि उत्पन्न करने के लिए पर्याप्त स्मार्ट होता है।

एवेंजर्स: पैरामीटर वॉर

ऐसी स्थितियाँ होती हैं जब हमें किसी विधि को कॉल करने के कई तरीके चाहिए होते हैं। अपनी खुद की आर्टिफिशियल इंटेलिजेंस क्यों नहीं बनाते? Amazon के पास Alexa है, Apple के पास सिरी है, तो हमारे पास एक क्यों नहीं होना चाहिए? :) फिल्म आयरन मैन में, टोनी स्टार्क अपनी खुद की अविश्वसनीय कृत्रिम बुद्धि, जार्विस बनाता है। आइए उस भयानक चरित्र को श्रद्धांजलि दें और उसके सम्मान में हमारे एआई का नाम दें। :) पहली चीज जो हमें करने की ज़रूरत है वह जार्विस को कमरे में प्रवेश करने वाले लोगों को नमस्ते कहना सिखाना है (यह अजीब होगा अगर ऐसी अद्भुत बुद्धि असभ्य हो)।

public class Jarvis {

    public void sayHi(String name) {
        System.out.println("Good evening, " + name + ". How are you?");
    }

    public static void main(String[] args) {
        Jarvis jarvis = new Jarvis();
        jarvis.sayHi("Tony Stark");
    }
}

कंसोल आउटपुट:

Good evening, Tony Stark. How are you?

बहुत अच्छा! जार्विस अब मेहमानों का स्वागत करने में सक्षम है। बेशक, अधिक बार यह उनके गुरु, टोनी स्टार्क नहीं होगा। लेकिन क्या हुआ अगर वह अकेले नहीं आया! हमारी SayHi () पद्धति केवल एक तर्क को स्वीकार करती है। और इसलिए यह केवल कमरे में प्रवेश करने वाले एक व्यक्ति का अभिवादन कर सकता है, और दूसरे की उपेक्षा करेगा। बहुत विनम्र नहीं, क्या आप सहमत नहीं हैं? :/

जावा विधि ओवरलोडिंग

इस मामले में, हम केवल एक ही नाम के साथ दो तरीकों को लिखकर समस्या को हल कर सकते हैं, लेकिन अलग-अलग पैरामीटर:

public class Jarvis {

    public void sayHi(String firstGuest) {
        System.out.println("Good evening, " + firstGuest + ". How are you?");
    }

    public void sayHi(String firstGuest, String secondGuest) {
        System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
    }
}

इसे मेथड ओवरलोडिंग कहा जाता है। मेथड ओवरलोडिंग हमारे प्रोग्राम को अधिक लचीला बनाता है और काम करने के विभिन्न तरीकों को समायोजित करता है। आइए समीक्षा करें कि यह कैसे काम करता है:

public class Jarvis {

    public void sayHi(String firstGuest) {
        System.out.println("Good evening, " + firstGuest + ". How are you?");
    }

    public void sayHi(String firstGuest, String secondGuest) {
        System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
    }

    public static void main(String[] args) {
        Jarvis jarvis = new Jarvis();
        jarvis.sayHi("Tony Stark");
        jarvis.sayHi("Tony Stark", "Captain America");
    }
}

कंसोल आउटपुट:

Good evening, Tony Stark. How are you?
Good evening, Tony Stark and Captain America. How are you?

बढ़िया, दोनों संस्करणों ने काम किया। :) लेकिन हमने समस्या का समाधान नहीं किया! क्या होगा अगर तीन मेहमान हैं? बेशक, हम SayHi () विधि को फिर से अधिभारित कर सकते हैं, ताकि यह तीन अतिथि नामों को स्वीकार कर सके। लेकिन 4 या 5 हो सकते हैं। अनंत तक। क्या जार्विस को किसी भी संख्या में नामों को संभालने के लिए सिखाने का कोई बेहतर तरीका नहीं है, SayHi() विधि को दस लाख बार ओवरलोड किए बिना? : / बेशक वहाँ है! अगर ऐसा नहीं होता, तो क्या आपको लगता है कि जावा दुनिया की सबसे लोकप्रिय प्रोग्रामिंग भाषा होगी? ;)

public void sayHi(String...names) {

    for (String name: names) {
        System.out.println("Good evening, " + name + ". How are you?");
    }
}

जब ( स्ट्रिंग... नाम ) एक पैरामीटर के रूप में प्रयोग किया जाता है, तो यह इंगित करता है कि स्ट्रिंग्स का एक संग्रह विधि को पारित किया जाएगा। हमें पहले से निर्दिष्ट करने की आवश्यकता नहीं है कि कितने होंगे, इसलिए अब हमारी विधि अधिक लचीली है:

public class Jarvis {

    public void sayHi(String...names) {
        for (String name: names) {
            System.out.println("Good evening, " + name + ". How are you?");
        }
    }

    public static void main(String[] args) {
        Jarvis jarvis = new Jarvis();
        jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
    }
}

कंसोल आउटपुट:

Good evening, Tony Stark. How are you?
Good evening, Captain America. How are you?
Good evening, Black Widow. How are you?
Good evening, Hulk. How are you?

यहां कुछ कोड आपके लिए अपरिचित होंगे, लेकिन इसके बारे में चिंता न करें। यह अपने मूल में सरल है: विधि प्रत्येक नाम को बारी-बारी से लेती है और प्रत्येक अतिथि का स्वागत करती है! साथ ही, यह किसी भी पास की गई स्ट्रिंग्स के साथ काम करेगा! दो, दस, यहां तक ​​कि एक हजार—यह विधि किसी भी संख्या में मेहमानों के साथ ठीक से काम करेगी। क्या आपको नहीं लगता कि सभी संभावनाओं के लिए विधि को ओवरलोड करने से कहीं अधिक सुविधाजनक है? :) यहाँ एक और महत्वपूर्ण बिंदु है: तर्कों का क्रम मायने रखता है! मान लीजिए कि हमारी विधि एक स्ट्रिंग और एक संख्या लेती है:

public class Person {

    public static void sayYourAge(String greeting, int age) {
        System.out.println(greeting + " " + age);
    }

    public static void main(String[] args) {
        sayYourAge("My age is ", 33);
        sayYourAge(33, "My age is "); // Error!
    }
}

यदि व्यक्ति वर्ग की SayYourAge विधि इनपुट के रूप में एक स्ट्रिंग और संख्या लेती है, तो प्रोग्राम को उन्हें उस विशिष्ट क्रम में पास करना होगा! यदि हम उन्हें एक अलग क्रम में पास करते हैं, तो संकलक एक त्रुटि उत्पन्न करेगा और व्यक्ति अपनी आयु नहीं कह पाएगा। वैसे, कंस्ट्रक्टर, जिन्हें हमने पिछले पाठ में कवर किया था, वे भी विधियाँ हैं! आप उन्हें ओवरलोड भी कर सकते हैं (यानी पैरामीटर के विभिन्न सेट के साथ कई कन्स्ट्रक्टर बनाएं) और पारित तर्कों का क्रम भी उनके लिए मौलिक रूप से महत्वपूर्ण है। वे असली तरीके हैं! :)

फिर भी मापदंडों के संबंध में

हां, क्षमा करें, हमने अभी उनका काम पूरा नहीं किया है। :) अब हम जिस विषय का अध्ययन करेंगे वह बहुत महत्वपूर्ण है। इस बात की 90% संभावना है कि आपसे भविष्य के प्रत्येक साक्षात्कार में इस बारे में पूछा जाएगा! आइए तर्कों को विधियों में पारित करने के बारे में बात करते हैं। एक साधारण उदाहरण पर विचार करें:

public class TimeMachine {

    public void goToFuture(int currentYear) {
        currentYear = currentYear+10;
    }

    public void goToPast(int currentYear) {
        currentYear = currentYear-10;
    }

    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        int currentYear = 2018;

        System.out.println("What year is it?");
        System.out.println(currentYear);

        timeMachine.goToPast(currentYear);
        System.out.println("How about now?");
        System.out.println(currentYear);
    }
}

टाइम मशीन के दो तरीके हैं। वे दोनों एक इनपुट के रूप में वर्तमान वर्ष का प्रतिनिधित्व करने वाली संख्या लेते हैं, और या तो इसके मूल्य को बढ़ाते या घटाते हैं (इस पर निर्भर करता है कि हम अतीत या भविष्य में जाना चाहते हैं)। लेकिन, जैसा कि आप कंसोल आउटपुट से देख सकते हैं, विधि काम नहीं करती है! कंसोल आउटपुट:

What year is it?
2018
How about now?
2018

हमने goToPast() मेथड में करंट ईयर वेरिएबल पास किया , लेकिन इसका मान नहीं बदला। हम 2018 में थे, और यहां हम रुके हैं। लेकिन क्यों? :/ क्योंकि जावा में प्रिमिटिव को वैल्यू द्वारा मेथड्स में पास किया जाता है। इसका क्या मतलब है? जब हम goToPast() मेथड को कॉल करते हैं और int वेरिएबल करंट ईयर (=2018) को पास करते हैं, तो मेथड को करंट ईयर वेरिएबल नहीं मिलता है, बल्कि इसकी एक कॉपी मिलती है। बेशक, इस कॉपी का मूल्य भी 2018 है, लेकिन कॉपी में कोई भी बदलाव किसी भी तरह से हमारे मूल करंट ईयर वैरिएबल को प्रभावित नहीं करता है! आइए अपने कोड को और अधिक स्पष्ट करें और देखें कि वर्तमान वर्ष के साथ क्या होता है:

public class TimeMachine {

    public void goToFuture(int currentYear) {
        currentYear = currentYear+10;
    }

    public void goToPast(int currentYear) {
        System.out.println("The goToPast method has started running!");
        System.out.println("currentYear inside the goToPast method (at the beginning) = " + currentYear);
        currentYear = currentYear-10;
        System.out.println("currentYear inside the goToPast method (at the end) = " + currentYear);
    }

    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        int currentYear = 2018;

        System.out.println("What was the year when the program started?");
        System.out.println(currentYear);

        timeMachine.goToPast(currentYear);
        System.out.println("And what year is it now?");
        System.out.println(currentYear);
    }
}

कंसोल आउटपुट:

What was the year when the program started?
2018
The goToPast method has started running!
currentYear inside the goToPast method (at the beginning) = 2018
currentYear inside the goToPast method (at the end) = 2008
And what year is it now?
2018

यह स्पष्ट रूप से दिखाता है कि goToPast() विधि को दिया गया चर केवल वर्तमान वर्ष की एक प्रति है । और प्रतिलिपि बदलने से "मूल" मान प्रभावित नहीं होता है। "संदर्भ द्वारा पास" का अर्थ ठीक विपरीत है। बिल्लियों पर अभ्यास करते हैं! मेरा मतलब है, देखते हैं कि संदर्भ से गुजरने से बिल्ली उदाहरण का उपयोग करना कैसा दिखता है। :)

public class Cat {

    int age;

    public Cat(int age) {
        this.age = age;
    }
}

अब अपनी टाइम मशीन की मदद से हम दुनिया की पहली बार यात्रा करने वाली बिल्ली स्मज को अतीत और भविष्य में भेजेंगे ! चलिए TimeMachine वर्ग को संशोधित करते हैं ताकि यह Cat वस्तुओं के साथ काम करे;

public class TimeMachine {

    public void goToFuture(Cat cat) {
        cat.age += 10;
    }

    public void goToPast(Cat cat) {
        cat.age -= 10;
    }    
}

अब विधियाँ केवल पास की गई संख्या को नहीं बदलती हैं। बल्कि, वे उस विशिष्ट Cat के आयु क्षेत्र को बदल देते हैं। आपको याद होगा कि यह हमारे लिए आदिम के साथ काम नहीं करता था, क्योंकि मूल संख्या नहीं बदली थी। देखते हैं क्या होगा!

public static void main(String[] args) {

    TimeMachine timeMachine = new TimeMachine();
    Cat smudge = new Cat(5);

    System.out.println("How old was Smudge when the program started?");
    System.out.println(smudge.age);

    timeMachine.goToFuture(smudge);
    System.out.println("How about now?");
    System.out.println(smudge.age);

    System.out.println("Holy smokes! Smudge has aged 10 years! Back up quickly!");
    timeMachine.goToPast(smudge);
    System.out.println("Did it work? Have we returned the cat to its original age?");
    System.out.println(smudge.age);
}

कंसोल आउटपुट:

How old was Smudge when the program started running?
5
How about now?
15
Holy smokes! Smudge has aged 10 years! Back up quickly!
Did it work? Have we returned the cat to its original age?
5

बहुत खूब! अब विधि ने कुछ अलग किया: हमारी बिल्ली काफी बूढ़ी हो गई, लेकिन फिर वह फिर से जवान हो गई! :) आइए जानने की कोशिश करें कि क्यों। आदिम के उदाहरण के विपरीत, जब वस्तुओं को एक विधि में पारित किया जाता है तो वे संदर्भ द्वारा पारित होते हैं। मूल स्मज ऑब्जेक्ट का संदर्भ चेंजएज () विधि को दिया गया था। इसलिए, जब हम विधि के अंदर smudge.age को बदलते हैं, तो हम स्मृति के उसी क्षेत्र को संदर्भित कर रहे हैं जहाँ हमारी वस्तु संग्रहीत है। यह उसी स्मज का संदर्भ है जिसे हमने शुरुआत में बनाया था। इसे "संदर्भ से गुजरना" कहा जाता है! हालाँकि, संदर्भों के साथ सब कुछ इतना आसान नहीं है। :) आइए अपना उदाहरण बदलने की कोशिश करें:

public class TimeMachine {

    public void goToFuture(Cat cat) {
        cat = new Cat(cat.age);
        cat.age += 10;
    }

    public void goToPast(Cat cat) {
        cat = new Cat(cat.age);
        cat.age -= 10;
    }

    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        Cat smudge = new Cat(5);

        System.out.println("How old was Smudge when the program started?");
        System.out.println(smudge.age);

        timeMachine.goToFuture(smudge);
        System.out.println ("Smudge went to the future! Has his age changed?");
        System.out.println(smudge.age);

        System.out.println ("And if you try going back?");
        timeMachine.goToPast(smudge);
        System.out.println(smudge.age);
    }
}

कंसोल आउटपुट:

How old was Smudge when the program started running?
5
Smudge went to the future! Has his age changed?
5
And if you try going back?
5

यह फिर से काम नहीं करता! О_О आइए जानें कि क्या हुआ। :) यह सब कुछ goToPast / goToFuture विधियों और संदर्भों के काम करने के तरीके से संबंधित है । अब, आपका ध्यान, कृपया! संदर्भ और विधियां कैसे काम करती हैं, यह समझने के लिए यह सबसे महत्वपूर्ण बात है। तथ्य यह है कि, जब हम goToFuture(Cat cat) विधि को कॉल करते हैं, तो यह cat ऑब्जेक्ट के संदर्भ की एक प्रति होती है जो पारित हो जाती है, न कि स्वयं संदर्भ। इस प्रकार, जब हम किसी वस्तु को किसी विधि से पास करते हैं, तो वस्तु के दो संदर्भ होते हैं। क्या हो रहा है यह समझने के लिए यह बहुत महत्वपूर्ण है। यही कारण है कि बिल्ली की उम्र हमारे पिछले उदाहरण में नहीं बदली। पिछले उदाहरण में, उम्र बदलते समय, हमने केवल goToFuture() को दिए गए संदर्भ को लियाविधि, और इसका उपयोग स्मृति में वस्तु को खोजने और उसकी उम्र बदलने के लिए किया ( cat.age += 10 )। लेकिन अब, goToFuture() मेथड के अंदर, हम एक नया ऑब्जेक्ट बना रहे हैं ( cat = new Cat(cat.age) ), और इस ऑब्जेक्ट को वही रेफरेंस कॉपी असाइन की जाती है जो मेथड को पास की गई थी। नतीजतन:

• पहला संदर्भ ( कैट स्मज = न्यू कैट (5) ) मूल बिल्ली की ओर इशारा करता है (5 साल की उम्र के साथ)
• उसके बाद, जब हमने कैट वेरिएबल को goToPast() मेथड पास किया और इसे एक नया ऑब्जेक्ट असाइन किया, तो रेफरेंस कॉपी हो गया।

और यह हमें अंतिम परिणाम पर ले आया: दो संदर्भ दो अलग-अलग वस्तुओं की ओर इशारा करते हैं। लेकिन हमने उनमें से केवल एक की उम्र बदल दी (विधि के अंदर बनाई गई)।

cat.age += 10;

और हां, main() मेथड में हम कंसोल पर देख सकते हैं कि बिल्ली की उम्र, smudge.age , नहीं बदली है। आखिरकार, स्मज एक संदर्भ चर है जो अभी भी 5 साल की उम्र के साथ पुरानी, ​​मूल वस्तु की ओर इशारा करता है, और हमने उस वस्तु के साथ कुछ नहीं किया। हमारे सभी आयु परिवर्तन नई वस्तु पर किए गए थे। तो, यह पता चला है कि वस्तुओं को संदर्भ द्वारा विधियों में पारित किया जाता है। वस्तुओं की प्रतियाँ कभी भी स्वचालित रूप से नहीं बनाई जाती हैं। यदि आप किसी बिल्ली वस्तु को किसी विधि में पास करते हैं और उसकी आयु बदलते हैं, तो आप उसकी आयु बदल देंगे। लेकिन मान और/या कॉलिंग विधियों को निर्दिष्ट करते समय संदर्भ चर की प्रतिलिपि बनाई जाती है! आइए यहां दोहराते हैं कि हमने प्रिमिटिव पास करने के बारे में क्या कहा: "जब हम चेंजइंट () मेथड को कॉल करते हैं और इंट पास करते हैंचर x (= 15) , विधि को x चर ही नहीं मिलता है, बल्कि इसकी एक प्रति है। इसलिए, कॉपी में किए गए कोई भी परिवर्तन हमारे मूल x को प्रभावित नहीं करते हैंजावा में (अनुभवी डेवलपर्स के बीच भी) तर्क कैसे पारित किए जाते हैं, इस बारे में एक से अधिक बार बहस करना समाप्त हो जाएगा। लेकिन, अब आप जानते हैं कि यह कैसे काम करता है। इसे जारी रखो! :) आपने जो सीखा है उसे सुदृढ़ करने के लिए, हमारा सुझाव है कि आप हमारे जावा कोर्स से एक वीडियो सबक देखें