జావాలో పద్ధతులు

మళ్ళీ హలో! చివరి పాఠంలో మేము తరగతులు మరియు కన్స్ట్రక్టర్లతో పరిచయం పొందాము మరియు మా స్వంతంగా ఎలా సృష్టించాలో నేర్చుకున్నాము. ఈ రోజు మనం జావా మెథడ్స్‌తో బాగా పరిచయం అవుతాము, ఇది తరగతుల్లో ముఖ్యమైన భాగం. జావాలోని మెథడ్స్ అనేది ప్రోగ్రామ్‌లో నిర్దిష్ట ఆపరేషన్ చేయడానికి మిమ్మల్ని అనుమతించే ఆదేశాల సమితి. ఇతర మాటలలో, ఒక పద్ధతి ఒక ఫంక్షన్; మీ తరగతి చేయగలిగింది. ఇతర ప్రోగ్రామింగ్ భాషలలో, పద్ధతులను తరచుగా "ఫంక్షన్స్" అని పిలుస్తారు, కానీ జావాలో "పద్ధతి" అనే పదం సర్వసాధారణం. :) మీకు గుర్తుంటే, చివరి పాఠంలో మేము క్యాట్ క్లాస్ కోసం సరళమైన పద్ధతులను సృష్టించాము, తద్వారా మా పిల్లులు మియావ్ అని మరియు దూకవచ్చు:

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() పద్ధతిలో , మేము గణనలను నిర్వహిస్తాము, మా వస్తువు యొక్క డేటాను దాని వాల్యూమ్‌ను సూచించే సంఖ్యగా మారుస్తాము (మేము పొడవు, వెడల్పు మరియు ఎత్తును గుణిస్తాము). ఈ సంఖ్య పద్ధతి యొక్క ఫలితం అవుతుంది. పద్ధతి యొక్క డిక్లరేషన్ పబ్లిక్ int getVolume గా వ్రాయబడిందని గమనించండి . అంటే ఈ పద్ధతి తప్పనిసరిగా ఒక పూర్ణాంకాన్ని అందించాలి . మేము పద్ధతి యొక్క రిటర్న్ విలువను లెక్కించాము మరియు ఇప్పుడు మనం దానిని మా పద్ధతి అని పిలిచే ప్రోగ్రామ్‌కు తిరిగి ఇవ్వాలి. జావాలో పద్ధతి యొక్క ఫలితాన్ని అందించడానికి, మేము రిటర్న్ అనే కీవర్డ్‌ని ఉపయోగిస్తాము. రిటర్న్ వాల్యూమ్;

జావా మెథడ్ పారామితులు

కాల్ చేస్తున్నప్పుడు మనం "వాదనలు" అనే విలువలను ఒక పద్ధతికి పంపవచ్చు. ఒక పద్ధతి యొక్క ప్రకటన వేరియబుల్స్ యొక్క జాబితాను కలిగి ఉంటుంది, ఇది పద్ధతి అంగీకరించగల వేరియబుల్స్ యొక్క రకం మరియు క్రమాన్ని మాకు తెలియజేస్తుంది. ఈ జాబితాను "పద్ధతి పారామితులు" అంటారు. మా ట్రక్ క్లాస్ యొక్క 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. ప్రోగ్రామ్ ఆఫీసర్ .checkTruck(మొదటి) పద్ధతిని పిలుస్తుంది. పద్ధతి ప్రతిదానిని లెక్కించి, ఆపై నిజమని తిరిగి ఇస్తుంది , ఆ తర్వాత ప్రోగ్రామ్ బూలియన్ వేరియబుల్ 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!");
    }
}

అధికారి యొక్క వ్యాఖ్యలు ప్రదర్శించబడవు, ఎందుకంటే పద్ధతి ఇప్పటికే ఫలితాన్ని అందించింది మరియు రద్దు చేయబడింది! ప్రోగ్రామ్ పద్ధతిని పిలిచిన ప్రదేశానికి తిరిగి వస్తుంది. మీరు దీని కోసం చూడవలసిన అవసరం లేదు: మీరు రిటర్న్ స్టేట్‌మెంట్ తర్వాత కోడ్‌ని వ్రాయడానికి ప్రయత్నించినప్పుడు జావా కంపైలర్ ఎర్రర్‌ను సృష్టించేంత స్మార్ట్‌గా ఉంటుంది .

ఎవెంజర్స్: పారామీటర్ వార్

మేము ఒక పద్ధతిని కాల్ చేయడానికి అనేక మార్గాలను కోరుకునే సందర్భాలు ఉన్నాయి. మన స్వంత కృత్రిమ మేధస్సును ఎందుకు సృష్టించకూడదు? అమెజాన్‌లో అలెక్సా ఉంది, యాపిల్‌లో సిరి ఉంది, కాబట్టి మనకు ఎందుకు ఉండకూడదు? :) ఐరన్ మ్యాన్ చిత్రంలో, టోనీ స్టార్క్ తన స్వంత అద్భుతమైన కృత్రిమ మేధస్సును సృష్టించాడు, జార్విస్. ఆ అద్భుతమైన పాత్రకు నివాళులర్పిద్దాం మరియు అతని గౌరవార్థం మన 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?");
    }
}

( స్ట్రింగ్... పేర్లు ) పారామీటర్‌గా ఉపయోగించినప్పుడు, స్ట్రింగ్‌ల సేకరణ పద్ధతికి పంపబడుతుందని సూచిస్తుంది. ఎన్ని ఉంటాయో మేము ముందుగా పేర్కొనవలసిన అవసరం లేదు, కాబట్టి ఇప్పుడు మా పద్ధతి మరింత సరళమైనది:

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;
    }
}

ఇప్పుడు మన టైమ్ మెషిన్ సహాయంతో ప్రపంచంలోనే మొట్టమొదటిసారి ప్రయాణించే పిల్లి అయిన స్మడ్జ్‌ని గతం మరియు భవిష్యత్తులోకి పంపుతాము ! టైమ్‌మెషిన్ క్లాస్‌ని సవరిద్దాం, తద్వారా ఇది క్యాట్ వస్తువులతో పని చేస్తుంది;

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ని మార్చినప్పుడు , మన వస్తువు నిల్వ చేయబడిన అదే మెమరీ ప్రాంతాన్ని మేము సూచిస్తాము. ఇది మేము మొదట సృష్టించిన అదే స్మడ్జ్‌కి సూచన. దీనినే "పాసింగ్ బై రిఫరెన్స్" అంటారు! అయితే, సూచనలతో కూడిన ప్రతిదీ అంత సులభం కాదు. :) మన ఉదాహరణను మార్చడానికి ప్రయత్నిద్దాం:

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) ), మరియు ఈ ఆబ్జెక్ట్‌కు పద్ధతికి పంపబడిన అదే సూచన కాపీని కేటాయించారు. ఫలితంగా:

• మొదటి సూచన ( క్యాట్ స్మడ్జ్ = కొత్త పిల్లి (5) ) అసలైన పిల్లిని (5 సంవత్సరాల వయస్సుతో) సూచిస్తుంది
• ఆ తర్వాత, మేము క్యాట్ వేరియబుల్‌ను goToPast() పద్ధతిని ఆమోదించినప్పుడు మరియు దానికి కొత్త వస్తువును కేటాయించినప్పుడు, సూచన కాపీ చేయబడింది.

మరియు ఇది మమ్మల్ని తుది ఫలితానికి తీసుకువచ్చింది: రెండు వేర్వేరు వస్తువులను సూచించే రెండు సూచనలు. కానీ మేము వారిలో ఒకరి వయస్సును మాత్రమే మార్చాము (పద్ధతి లోపల సృష్టించబడినది).

cat.age += 10;

మరియు వాస్తవానికి, ప్రధాన() పద్ధతిలో మనం కన్సోల్‌లో పిల్లి వయస్సు, smudge.age , మారలేదని చూడవచ్చు. అన్నింటికంటే, స్మడ్జ్ అనేది రిఫరెన్స్ వేరియబుల్, ఇది ఇప్పటికీ 5 ఏళ్ల వయస్సులో ఉన్న పాత, అసలైన వస్తువును సూచిస్తుంది మరియు మేము ఆ వస్తువుతో ఏమీ చేయలేదు. మా వయస్సు మార్పులన్నీ కొత్త వస్తువుపై ప్రదర్శించబడ్డాయి. కాబట్టి, వస్తువులు సూచన ద్వారా పద్ధతులకు పంపబడుతున్నాయని తేలింది. వస్తువుల కాపీలు స్వయంచాలకంగా సృష్టించబడవు. మీరు పిల్లి వస్తువును ఒక పద్ధతికి పంపి, దాని వయస్సును మార్చినట్లయితే, మీరు దాని వయస్సును మారుస్తారు. కానీ విలువలు మరియు/లేదా కాల్ చేసే పద్ధతులను కేటాయించేటప్పుడు రిఫరెన్స్ వేరియబుల్స్ కాపీ చేయబడతాయి! ప్రైమిటివ్‌లను పాస్ చేయడం గురించి మనం ఏమి చెప్పామో ఇక్కడ పునరావృతం చేద్దాం: "మనం changeInt() పద్ధతిని పిలిచినప్పుడు మరియు పూర్ణాంకానికి పాస్ చేసినప్పుడువేరియబుల్ x (=15) , పద్ధతి x వేరియబుల్‌ను పొందదు , బదులుగా దాని కాపీని పొందుతుంది. కాబట్టి, కాపీకి చేసిన ఏవైనా మార్పులు మా అసలు xని ప్రభావితం చేయవుజావాలో (అనుభవజ్ఞులైన డెవలపర్‌లలో కూడా) ఆర్గ్యుమెంట్‌లు ఎలా ఆమోదించబడతాయనే దాని గురించి ఒకటి కంటే ఎక్కువసార్లు వాదించడం ఇప్పటికీ ముగుస్తుంది. అయితే, ఇది ఎలా పని చేస్తుందో ఇప్పుడు మీకు తెలుసు. కొనసాగించు! :) మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము