जावा मध्ये पद्धती

हॅलो पुन्हा! शेवटच्या धड्यात आम्ही वर्ग आणि कन्स्ट्रक्टरशी परिचित झालो आणि स्वतःचे कसे तयार करायचे ते शिकलो. आज आपण जावा पद्धतींशी अधिक चांगल्या प्रकारे परिचित होऊ, जो वर्गांचा एक आवश्यक भाग आहे. Java मधील पद्धती हा आदेशांचा एक संच आहे जो तुम्हाला प्रोग्राममध्ये विशिष्ट ऑपरेशन करण्यास परवानगी देतो. दुसऱ्या शब्दांत, एक पद्धत एक कार्य आहे; तुमचा वर्ग करू शकणारे काहीतरी. इतर प्रोग्रामिंग भाषांमध्ये, पद्धतींना "फंक्शन्स" म्हटले जाते, परंतु जावामध्ये "पद्धत" हा शब्द अधिक सामान्य आहे. :) जर तुम्हाला आठवत असेल तर, शेवटच्या धड्यात आम्ही मांजर वर्गासाठी सोप्या पद्धती तयार केल्या आहेत, जेणेकरून आमच्या मांजरी म्याऊ आणि उडी म्हणू शकतील:

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() आणि jump() या आमच्या वर्गाच्या पद्धती आहेत. आणि या पद्धती चालवल्याने खालील कन्सोल आउटपुट मिळते:

Meow!
Pounce!

आमच्या पद्धती अगदी सोप्या आहेत: ते फक्त कन्सोलवर मजकूर आउटपुट करतात. परंतु Java मध्ये, पद्धतींचे एक महत्त्वाचे कार्य आहे: ते ऑब्जेक्टच्या डेटावर क्रिया करतात. ते ऑब्जेक्टचा डेटा बदलतात, त्याचे रूपांतर करतात, ते प्रदर्शित करतात आणि त्यासह इतर गोष्टी करतात. आमच्या सध्याच्या पद्धती कॅट ऑब्जेक्टच्या डेटासह काहीही करत नाहीत . चला अधिक स्पष्ट उदाहरण पाहू:

public class Truck {

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

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

उदाहरणार्थ, येथे आमच्याकडे ट्रकचे प्रतिनिधित्व करणारा वर्ग आहे . सेमी ट्रकची लांबी, रुंदी, उंची आणि वजन असते (जे आपल्याला नंतर आवश्यक असेल). getVolume() पद्धतीत , आम्‍ही आकडेमोड करतो, आमच्‍या ऑब्‍जेक्‍टच्‍या डेटाला त्‍याच्‍या व्हॉल्यूमचे प्रतिनिधित्व करणार्‍या संख्‍येत रूपांतरित करतो (आम्ही लांबी, रुंदी आणि उंचीचा गुणाकार करतो). ही संख्या पद्धतीचा परिणाम असेल. लक्षात घ्या की पद्धतीची घोषणा सार्वजनिक इंट getVolume म्हणून लिहिलेली आहे . याचा अर्थ असा की या पद्धतीने int परत करणे आवश्यक आहे . आम्ही मेथडचे रिटर्न व्हॅल्यू मोजले, आणि आता आम्हाला ते आमच्या मेथड नावाच्या प्रोग्रामवर परत करणे आवश्यक आहे. Java मध्ये पद्धतीचा निकाल देण्यासाठी, आम्ही रिटर्न हा कीवर्ड वापरतो. रिटर्न व्हॉल्यूम;

Java पद्धत पॅरामीटर्स

कॉल करताना आम्ही "वितर्क" नावाची मूल्ये एका पद्धतीमध्ये पास करू शकतो. पद्धतीच्या घोषणेमध्ये व्हेरिएबल्सची सूची समाविष्ट असते जी पद्धत स्वीकारू शकते अशा व्हेरिएबल्सचा प्रकार आणि क्रम सांगते. या सूचीला "पद्धत पॅरामीटर्स" म्हणतात. आमच्या ट्रक क्लासची getVolume() पद्धत सध्या कोणतेही पॅरामीटर्स परिभाषित करत नाही, म्हणून आमच्या ट्रकचे उदाहरण वाढवण्याचा प्रयत्न करूया. BridgeOfficer नावाचा नवीन वर्ग तयार करा . हा पुलावर ड्युटीवर असलेला एक पोलीस अधिकारी आहे, जो सर्व पासिंग ट्रक तपासतो की त्यांचा भार अनुमत वजनापेक्षा जास्त आहे की नाही.

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 () आहेपद्धत तुम्ही या पद्धतीचा युक्तिवाद म्हणून डॉक्टरांची नोट पास करता (त्याशिवाय, पद्धत कार्य करणार नाही आणि तुम्हाला पैसे मिळणार नाहीत!). मग तुमची नोट वापरून पद्धतीमध्ये आवश्यक गणना केली जाते (कंपनीने तुम्हाला किती पैसे द्यावेत याची गणना करण्यासाठी अकाउंटंट त्याचा वापर करतो), आणि तुमच्या कामाचा परिणाम (पैसे) तुम्हाला परत केले जातात. आमचा कार्यक्रम अशाच प्रकारे कार्य करतो. ते एक पद्धत कॉल करते, त्यावर डेटा पास करते आणि शेवटी परिणाम प्राप्त करते. आमच्या BridgeOfficer प्रोग्रामची मुख्य() पद्धत येथे आहे:

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 आहे. प्रोग्राम ऑफिसर.चेकट्रक(प्रथम) पद्धतीला कॉल करतो. पद्धत सर्व गोष्टींची गणना करते आणि नंतर true परत करते , जे प्रोग्राम नंतर बुलियन व्हेरिएबल 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!");
    }
}

अधिकाऱ्याच्या टिप्पण्या प्रदर्शित केल्या जाणार नाहीत, कारण पद्धत आधीच निकाल परत आली आहे आणि संपुष्टात आली आहे! प्रोग्राम ज्या ठिकाणी कॉल केला होता त्या ठिकाणी परत येतो. तुम्हाला हे पाहण्याची गरज नाही: तुम्ही रिटर्न स्टेटमेंटनंतर कोड लिहिण्याचा प्रयत्न करता तेव्हा एरर निर्माण करण्यासाठी Java कंपाइलर पुरेसे स्मार्ट आहे .

अॅव्हेंजर्स: पॅरामीटर वॉर

अशी परिस्थिती असते जेव्हा आम्हाला पद्धत कॉल करण्याचे अनेक मार्ग हवे असतात. आपली स्वतःची कृत्रिम बुद्धिमत्ता का तयार करत नाही? ऍमेझॉनकडे अलेक्सा आहे, ऍपलकडे सिरी आहे, मग आपल्याकडे का नसावे? :) आयर्न मॅन या चित्रपटात, टोनी स्टार्कने स्वतःची अविश्वसनीय कृत्रिम बुद्धिमत्ता, जार्विस तयार केली. चला त्या अद्भुत व्यक्तिरेखेला आदरांजली वाहू आणि त्याच्या सन्मानार्थ आपल्या AI चे नाव देऊ. :) सर्वप्रथम आपल्याला जार्विसला खोलीत प्रवेश करणार्‍यांना नमस्कार करायला शिकवावे लागेल (अशी आश्चर्यकारक बुद्धी असभ्य ठरली तर ते विचित्र होईल).

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() पद्धत फक्त एक युक्तिवाद स्वीकारते. आणि म्हणून ते खोलीत प्रवेश करणार्या एका व्यक्तीला फक्त अभिवादन करू शकते आणि दुसर्याकडे दुर्लक्ष करेल. फार विनम्र नाही, तुम्हाला पटत नाही का? :/

जावा पद्धत ओव्हरलोडिंग

या प्रकरणात, आम्ही समान नावाने फक्त 2 पद्धती लिहून समस्या सोडवू शकतो, परंतु भिन्न पॅरामीटर्स:

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?");
    }
}

जेव्हा ( String... names ) हे पॅरामीटर म्हणून वापरले जाते, तेव्हा ते सूचित करते की स्ट्रिंग्सचा संग्रह पद्धतीकडे पाठवला जाईल. तेथे किती असतील हे आम्हाला आगाऊ निर्दिष्ट करण्याची गरज नाही, म्हणून आता आमची पद्धत अधिक लवचिक आहे:

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 व्हेरिएबल currentYear (=2018) पास करतो, तेव्हा त्या पद्धतीला currentYear व्हेरिएबल मिळत नाही, तर त्याची प्रत मिळते. अर्थात, या कॉपीचे मूल्य देखील 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() पद्धतीवर पास केलेले व्हेरिएबल फक्त currentYear ची प्रत आहे . आणि कॉपी बदलल्याने "मूळ" मूल्यावर परिणाम होत नाही. "संदर्भातून पास" म्हणजे अगदी उलट. चला मांजरींवर सराव करूया! म्हणजे, मांजरीचे उदाहरण वापरून संदर्भ देऊन काय दिसते ते पाहू. :)

public class Cat {

    int age;

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

आता आमच्या टाइम मशीनच्या मदतीने आम्ही Smudge ही जगातील पहिली वेळ प्रवास करणारी मांजर भूतकाळात आणि भविष्यात पाठवू! चला TimeMachine क्लासमध्ये बदल करूया जेणेकरून ते कॅट ऑब्जेक्ट्ससह कार्य करेल;

public class TimeMachine {

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

    public void goToPast(Cat cat) {
        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("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

व्वा! आता या पद्धतीने काहीतरी वेगळे केले: आमची मांजर खूपच वृद्ध झाली, परंतु नंतर ती पुन्हा तरुण झाली! :) चला कारण शोधण्याचा प्रयत्न करूया. आदिम उदाहरणाच्या विपरीत, जेव्हा ऑब्जेक्ट्स एका पद्धतीमध्ये पास केले जातात तेव्हा ते संदर्भाद्वारे पास केले जातात. मूळ स्मज ऑब्जेक्टचा संदर्भ changeAge() पद्धतीला पाठवला गेला . म्हणून, जेव्हा आपण पद्धतीमध्ये smudge.age बदलतो , तेव्हा आपण मेमरीच्या त्याच क्षेत्राचा संदर्भ घेतो जिथे आपला ऑब्जेक्ट संग्रहित केला जातो. आम्ही सुरुवातीला तयार केलेल्या त्याच Smudge चा संदर्भ आहे. याला म्हणतात "संदर्भातून जाणे"! तथापि, संदर्भांसह सर्वकाही इतके सोपे नाही. :) चला आमचे उदाहरण बदलण्याचा प्रयत्न करूया:

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) पद्धतीला कॉल करतो, तेव्हा ती कॅट ऑब्जेक्टच्या संदर्भाची प्रत असते जी पास होते, संदर्भाची नाही. अशा प्रकारे, जेव्हा आपण एखाद्या पद्धतीमध्ये ऑब्जेक्ट पास करतो, तेव्हा ऑब्जेक्टचे दोन संदर्भ असतात. काय घडत आहे हे समजून घेण्यासाठी हे खूप महत्वाचे आहे. आमच्या शेवटच्या उदाहरणात मांजरीचे वय बदलले नाही हे नेमके कारण आहे. मागील उदाहरणामध्ये, वय बदलताना, आम्ही फक्त goToFuture() कडे दिलेला संदर्भ घेतला.पद्धत, आणि मेमरीमध्ये ऑब्जेक्ट शोधण्यासाठी आणि त्याचे वय बदलण्यासाठी त्याचा वापर केला ( cat.age += 10 ). पण आता, goToFuture() पद्धतीच्या आत, आम्ही एक नवीन ऑब्जेक्ट तयार करत आहोत ( cat = new Cat(cat.age) ), आणि या ऑब्जेक्टला तीच संदर्भ प्रत नियुक्त केली आहे जी पद्धत पास केली होती. परिणामी:

• पहिला संदर्भ ( Cat smudge = new Cat (5) ) मूळ मांजरीकडे निर्देश करतो (वय 5 सह)
• त्यानंतर, जेव्हा आम्ही cat व्हेरिएबल goToPast() पद्धत पास केली आणि त्याला एक नवीन ऑब्जेक्ट नियुक्त केला, तेव्हा संदर्भ कॉपी केला गेला.

आणि यामुळे आम्हाला अंतिम परिणामापर्यंत पोहोचवले: दोन संदर्भ दोन भिन्न वस्तूंकडे निर्देश करतात. परंतु आम्ही त्यापैकी फक्त एकाचे वय बदलले (पद्धतीमध्ये तयार केलेले).

cat.age += 10;

आणि अर्थातच, main() पद्धतीमध्ये आपण कन्सोलवर पाहू शकतो की मांजरीचे वय, smudge.age , बदललेले नाही. शेवटी, smudge एक संदर्भ व्हेरिएबल आहे जो अजूनही 5 वर्षांच्या जुन्या, मूळ ऑब्जेक्टकडे निर्देश करतो आणि आम्ही त्या ऑब्जेक्टसह काहीही केले नाही. आमचे सर्व वय बदल नवीन ऑब्जेक्टवर केले गेले. तर, असे दिसून आले की ऑब्जेक्ट्स संदर्भानुसार पद्धतींमध्ये दिले जातात. वस्तूंच्या प्रती कधीही आपोआप तयार होत नाहीत. जर तुम्ही एखाद्या मांजरीच्या वस्तूला एखाद्या पद्धतीने पास केले आणि तिचे वय बदलले तर तुम्ही त्याचे वय बदलाल. परंतु मूल्ये आणि/किंवा कॉलिंग पद्धती नियुक्त करताना संदर्भ चल कॉपी केले जातात! प्रिमिटिव्ह पास करण्याबद्दल आपण काय म्हटले ते येथे पुन्हा करूया: "जेव्हा आपण changeInt() पद्धत कॉल करतो आणि int पास करतोव्हेरिएबल x (=15) , पद्धतीला स्वतः x व्हेरिएबल मिळत नाही, तर त्याची प्रत मिळते. त्यामुळे, कॉपीमध्ये केलेले कोणतेही बदल आमच्या मूळ x वर परिणाम करत नाहीतJava मध्ये (अगदी अनुभवी डेव्हलपरमध्ये देखील) वितर्क कसे पास केले जातात याबद्दल एकापेक्षा जास्त वेळा वाद घालू. परंतु, आता तुम्हाला ते कसे कार्य करते हे माहित आहे. असच चालू राहू दे! :) तुम्ही जे शिकलात ते बळकट करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधील व्हिडिओ धडा पाहण्याचा सल्ला देतो