ஜாவா ரிட்டர்ன் திறவுச்சொல்

நமக்குத் தெரியும், ஜாவா மொழி ஒரு பொருள் சார்ந்த நிரலாக்க மொழி. வேறு வார்த்தைகளில் கூறுவதானால், அடிப்படைக் கருத்து, அதாவது அடித்தளத்தின் அடித்தளம், எல்லாம் ஒரு பொருள். வகுப்புகளைப் பயன்படுத்தி பொருள்கள் விவரிக்கப்பட்டுள்ளன. வகுப்புகள், நிலை மற்றும் நடத்தையை வரையறுக்கின்றன. எடுத்துக்காட்டாக, ஒரு வங்கிக் கணக்கில் கணக்கில் உள்ள பணத்தின் வடிவத்தில் மாநிலம் இருக்கலாம் மற்றும் கணக்கு இருப்பை அதிகரிக்கும் மற்றும் குறைக்கும் நடத்தைகள் இருக்கலாம். ஜாவாவில், நடத்தைகள் முறைகள் மூலம் செயல்படுத்தப்படுகின்றன. உங்கள் ஜாவா ஆய்வுகளின் ஆரம்பத்திலேயே முறைகளை எப்படி வரையறுப்பது என்பதைக் கற்றுக்கொள்வது. எடுத்துக்காட்டாக, ஆரக்கிளின் அதிகாரப்பூர்வ டுடோரியலில், " வரையறுத்தல் முறைகள் " என்ற தலைப்பின் கீழ். இங்கே கவனிக்க வேண்டிய இரண்டு முக்கியமான விஷயங்கள் உள்ளன:

• ஒவ்வொரு முறைக்கும் ஒரு கையொப்பம் உள்ளது. கையொப்பத்தில் முறையின் பெயர் மற்றும் அதன் உள்ளீட்டு அளவுருக்கள் உள்ளன.
• முறைகளுக்கு திரும்பும் வகை குறிப்பிடப்பட வேண்டும். ஒரு முறையின் திரும்பும் வகையை அதன் முறை அறிவிப்பில் அறிவிக்கிறீர்கள்.

திரும்பும் வகை முறை கையொப்பத்தின் ஒரு பகுதியாக இல்லை. மீண்டும், இது ஜாவா ஒரு வலுவாக தட்டச்சு செய்யப்பட்ட மொழி என்பதன் விளைவாகும், மேலும் கம்பைலர் எந்த வகையான வகைகள் பயன்படுத்தப்படுகிறது, எங்கு, முன்கூட்டியே மற்றும் முடிந்தவரை அறிய விரும்புகிறது. மீண்டும், இது நம்மை தவறுகளிலிருந்து காப்பாற்றுவதாகும். அடிப்படையில், இது ஒரு நல்ல காரணத்திற்காக. மேலும் இது மீண்டும் தரவுகளைக் கையாளும் ஒரு கலாச்சாரத்தை நமக்குள் புகுத்துகிறது என்று எனக்குத் தோன்றுகிறது. எனவே, திரும்பும் மதிப்பின் வகை முறைகளுக்குக் குறிப்பிடப்படுகிறது. ஜாவாவில் உள்ள ரிட்டர்ன் கீவார்ட் உண்மையில் ரிட்டர்னிங்கைச் செய்யப் பயன்படுகிறது.

ஜாவாவில் ரிட்டர்ன் என்ன செய்கிறது

இங்குள்ள ஆரக்கிள் டுடோரியலில் விவரிக்கப்பட்டுள்ளபடி, ரிட்டர்ன் திறவுச்சொல் ஒரு கட்டுப்பாட்டு ஓட்ட அறிக்கையாகும் . உத்தியோகபூர்வ டுடோரியலின் " ஒரு முறையிலிருந்து ஒரு மதிப்பை திரும்பப் பெறுதல் " பிரிவில் மதிப்புகளை எவ்வாறு திரும்பப் பெறுவது என்பது பற்றியும் நீங்கள் படிக்கலாம் . ஒரு முறையின் வருவாய் மதிப்பு முறையின் குறிப்பிட்ட திரும்பும் வகையுடன் பொருந்துகிறதா என்பதை கம்பைலர் கவனமாகக் கண்காணிக்கும். ஒரு உதாரணத்தைக் கருத்தில் கொள்ள Tutorialspoint இன் ஆன்லைன் 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.வகுப்பு

இறுதியாக. நீங்கள் எழுதக்கூடிய இந்த விசித்திரமான கட்டுமானம் உள்ளது: void.class . ம்ம். ஏன், அதன் அர்த்தம் என்ன? Java Reflection 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 ஆகியவற்றுக்கு என்ன வித்தியாசம்?