జావా రిటర్న్ కీవర్డ్

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

• ప్రతి పద్ధతికి సంతకం ఉంటుంది. సంతకం పద్ధతి యొక్క పేరు మరియు దాని ఇన్‌పుట్ పారామితులను కలిగి ఉంటుంది.
• పద్ధతుల కోసం రిటర్న్ రకాన్ని తప్పనిసరిగా పేర్కొనాలి. మీరు మెథడ్ రిటర్న్ రకాన్ని దాని మెథడ్ డిక్లరేషన్‌లో డిక్లేర్ చేస్తారు.

రిటర్న్ రకం పద్ధతి సంతకంలో భాగం కాదు. మళ్ళీ, ఇది జావా గట్టిగా టైప్ చేయబడిన భాష మరియు కంపైలర్ ఏ రకాలను ఉపయోగించాలో మరియు ఎక్కడ, ముందుగానే మరియు వీలైనంత ఎక్కువగా తెలుసుకోవాలనుకుంటుంది అనే వాస్తవం యొక్క పరిణామం. మళ్ళీ, ఇది తప్పుల నుండి మనలను రక్షించడం. సాధారణంగా, ఇదంతా మంచి కారణం కోసం. మరియు ఇది మరోసారి డేటాను నిర్వహించే సంస్కృతిని మనలో నింపుతుందని నాకు అనిపిస్తోంది. కాబట్టి, రిటర్న్ విలువ రకం పద్ధతుల కోసం పేర్కొనబడింది. మరియు జావాలోని రిటర్న్ కీవర్డ్ వాస్తవానికి రిటర్నింగ్ చేయడానికి ఉపయోగించబడుతుంది.

జావాలో రిటర్న్ ఏమి చేస్తుంది

రిటర్న్ కీవర్డ్ అనేది ఇక్కడ ఒరాకిల్ ట్యుటోరియల్‌లో వివరించిన విధంగా నియంత్రణ ప్రవాహ ప్రకటన . మీరు అధికారిక ట్యుటోరియల్‌లోని " పద్ధతి నుండి విలువను తిరిగి ఇవ్వడం " విభాగంలో విలువలను ఎలా తిరిగి ఇవ్వాలనే దాని గురించి కూడా చదవవచ్చు . కంపైలర్ ఒక పద్దతి యొక్క రిటర్న్ విలువ పద్ధతి యొక్క పేర్కొన్న రిటర్న్ రకానికి సరిపోలుతుందా లేదా అనేది జాగ్రత్తగా ట్రాక్ చేస్తుంది. ఒక ఉదాహరణను పరిశీలించడానికి ట్యుటోరియల్స్‌పాయింట్ యొక్క ఆన్‌లైన్ IDEని ఉపయోగిస్తాము . ప్రాథమిక ఉదాహరణను చూద్దాం:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

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

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println(getHelloMessage());
    }

    public static String getHelloMessage() {
        return "Hello World";
    }

}

మనం చూడగలిగినట్లుగా, రిటర్న్ విలువను సూచించడానికి మేము రిటర్న్ కీవర్డ్‌ని ఉపయోగించాము, దానిని మనం println పద్ధతికి పంపాము. getHelloMessage పద్ధతి యొక్క డిక్లరేషన్ పద్ధతి స్ట్రింగ్‌ను అందిస్తుంది అని సూచిస్తుంది . ఇది కంపైలర్‌ను మెథడ్ యొక్క చర్యలు ఎలా డిక్లేర్ చేయబడిందో దానికి అనుగుణంగా ఉన్నాయో లేదో తనిఖీ చేయడానికి అనుమతిస్తుంది. సహజంగానే, మెథడ్ డిక్లరేషన్‌లో పేర్కొన్న రిటర్న్ రకం వాస్తవానికి కోడ్‌లో తిరిగి వచ్చిన విలువ రకం కంటే విస్తృతంగా ఉంటుంది, అనగా ముఖ్యమైన విషయం ఏమిటంటే రకం మార్పిడి సాధ్యమవుతుంది. లేకపోతే, మేము కంపైల్ సమయంలో ఒక దోషాన్ని పొందుతాము: "లోపం: అననుకూల రకాలు" . మార్గం ద్వారా, మీకు బహుశా ఒక ప్రశ్న ఉండవచ్చు: ఎందుకు తిరిగి వస్తుందినియంత్రణ ప్రవాహ ప్రకటనగా పరిగణించబడుతుందా? ఎందుకంటే ఇది ప్రోగ్రామ్ యొక్క సాధారణ టాప్-డౌన్ ప్రవాహానికి అంతరాయం కలిగిస్తుంది. ఉదాహరణ:

public class HelloWorld {

    public static void main(String[] args) {
        if (args.length == 0) {
            return;
        }
        for (String arg : args) {
            System.out.println(arg);
        }
    }

}

మీరు ఉదాహరణ నుండి చూడగలిగినట్లుగా, మేము జావా ప్రోగ్రామ్‌లోని ప్రధాన పద్ధతిని వాదనలు లేకుండా పిలిస్తే అంతరాయం కలిగిస్తాము. రిటర్న్ స్టేట్‌మెంట్ తర్వాత మీకు కోడ్ ఉంటే, అది యాక్సెస్ చేయబడదని గుర్తుంచుకోవడం ముఖ్యం . మా స్మార్ట్ కంపైలర్ దానిని గమనించి, అటువంటి ప్రోగ్రామ్‌ను అమలు చేయకుండా మిమ్మల్ని నిరోధిస్తుంది. ఉదాహరణకు, ఈ కోడ్ కంపైల్ చేయదు:

public static void main(String[] args) {
        System.out.println("1");
        return;
// we use output method after return statement, which is incorrect
        System.out.println("2");
 }

దీని చుట్టూ తిరగడానికి ఒక డర్టీ హాక్ ఉంది. ఉదాహరణకు, డీబగ్గింగ్ ప్రయోజనాల కోసం లేదా కొన్ని ఇతర కారణాల కోసం. రిటర్న్ స్టేట్‌మెంట్‌ను if బ్లాక్‌లో చుట్టడం ద్వారా ఎగువ కోడ్‌ను పరిష్కరించవచ్చు :

if (2==2) {
    return;
}

ఎర్రర్ హ్యాండ్లింగ్ సమయంలో రిటర్న్ స్టేట్‌మెంట్

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

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Value: " + getIntValue());
    }

    public static int getIntValue() {
        int value = 1;
        try {
            System.out.println("Something terrible happens");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("Cached value: " + value);
            return value;
        } finally {
            value++;
            System.out.println("New value: " + value);
        }
    }

}

మొదటి చూపులో, చివరిగా ఎల్లప్పుడూ అమలు చేయబడినందున , 2 తిరిగి ఇవ్వబడాలని అనిపిస్తుంది . కానీ లేదు, రిటర్న్ విలువ 1 అవుతుంది మరియు చివరగా బ్లాక్‌లోని వేరియబుల్‌కు మార్పు విస్మరించబడుతుంది. అంతేకాకుండా, ఆ విలువలో ఒక వస్తువు ఉందని అనుకుందాం మరియు ఆఖరి బ్లాక్‌లో విలువ = శూన్యమని చెప్పాము . అప్పుడు ఆ వస్తువు, శూన్యం కాదు, క్యాచ్ బ్లాక్‌లో తిరిగి ఇవ్వబడుతుంది . కానీ రిటర్న్ స్టేట్‌మెంట్ ఫైనల్ బ్లాక్‌లో సరిగ్గా పని చేస్తుంది . సహజంగానే, రిటర్న్ స్టేట్‌మెంట్‌లతో కూడిన చిన్న ఆశ్చర్యాలకు మీ సహోద్యోగులు మీకు కృతజ్ఞతలు చెప్పరు.

శూన్యం.తరగతి

మరియు చివరకు. మీరు వ్రాయగలిగే ఈ వింత నిర్మాణం ఉంది: void.class . హ్మ్. ఎందుకు మరియు దాని అర్థం ఏమిటి? నిజంగా జావా రిఫ్లెక్షన్ API కి సంబంధించిన వివిధ ఫ్రేమ్‌వర్క్‌లు మరియు గమ్మత్తైన కేసులు ఉన్నాయి, ఇక్కడ ఇది చాలా ఉపయోగకరంగా ఉంటుంది. ఉదాహరణకు, మీరు ఏ రకమైన పద్ధతిని తిరిగి ఇస్తుందో తనిఖీ చేయవచ్చు:

import java.lang.reflect.Method;

public class HelloWorld {

    public void getVoidValue() {
    }

    public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == void.class);
        }
    }
}

మీరు పద్ధతుల్లో అసలు కోడ్‌ని భర్తీ చేయాల్సిన పరీక్ష ఫ్రేమ్‌వర్క్‌లలో ఇది ఉపయోగపడుతుంది. కానీ దీన్ని చేయడానికి, మీరు ఒక పద్ధతి ఎలా ప్రవర్తిస్తుందో అర్థం చేసుకోవాలి (అంటే అది ఏ రకంగా తిరిగి వస్తుంది). పై కోడ్‌లో ప్రధాన పద్ధతిని అమలు చేయడానికి రెండవ మార్గం కూడా ఉంది :

public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }

మీరు స్టాక్ ఓవర్‌ఫ్లో రెండింటి మధ్య వ్యత్యాసం గురించి చాలా ఆసక్తికరమైన చర్చను చదవవచ్చు: java.lang.Void మరియు void మధ్య తేడా ఏమిటి?