ஜாவாவில் அணுக முடியாத அறிக்கைக் குறியீடு பிழை

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

அணுக முடியாத குறியீடு என்றால் என்ன?

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

அணுக முடியாத குறியீடு மற்றும் டெட் குறியீடு

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

class DeadCode {
    void deadcode_Method(boolean b) {
    System.out.println("Reachable statement");
        if(true) {
        return;
        }
    System.out.println("Unreachable statement"); // dead code
    }
}

இறந்த குறியீட்டின் விஷயத்தில் நேரடி கம்பைலர் பிழை இல்லை என்பதால், அதைக் கண்டறிவது கடினம். இருப்பினும், System.out.printIn ரிட்டர்ன்களை நீங்கள் கவனமாகக் கண்காணித்தால் , இறந்த குறியீட்டைப் பிடிப்பது உங்களுக்குச் சிக்கலை ஏற்படுத்தாது.

நீங்கள் ஏன் அணுக முடியாத குறியீடு அறிக்கைகளைப் பெறுகிறீர்கள்

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

• பரிமாற்ற அறிக்கைகள். ரிட்டர்ன் ஸ்டேட்மெண்ட் மூலம் உங்கள் குறியீட்டை உடைத்தால், "திரும்ப = உண்மை" என்பதற்குப் பிறகு எதுவும் செயல்படுத்தப்படாது.
• முடிவிலா வளையம் - எல்லையற்ற வளையத்திற்குப் பிறகு நீங்கள் எழுதிய எந்தக் குறியீடும் செயல்படுத்தப்படாது, ஏனெனில் கணினி லூப் செயலை மீண்டும் வலியுறுத்தும். இவ்வாறு, உங்கள் குறியீட்டை பைட் குறியீட்டில் மாற்றும் போது, ​​கம்பைலர் அணுக முடியாத குறியீடு பிழையை அனுப்பும்.

இந்தச் சிக்கல்களைக் கொடியிடவும் சரிசெய்யவும் உங்களுக்கு உதவ, அவற்றைப் பெரிதாக்குவோம்.

அறிக்கைகள் திரும்ப

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

class GFG {
    public static void main(String args[])
    {
  
        System.out.println("My code will run");
  
        return;
  
        // ironically, this code will never run
        // here’s an unreachable code message a developer gets.
        System.out.println("My code will run");
    }
}

கம்பைலரில் ரிட்டர்ன் ஸ்டேட்மெண்ட் தவறாகப் பயன்படுத்தப்படுவது எப்படிக் காட்டப்படும் என்பது இங்கே:

prog.java:11: error: unreachable statement
System.out.println(“My code will run”);
^
1 error

நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்

பிரேக் அறிக்கைகள்

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

public class JavaCodeGeeks
     {
    public static void main(String[] args) {
     for(int i=1;i<5;i++)
        {
        System.out.println(i);
        break;
        System.out.println("Code after break");
        }
    }
}

கம்பைலர் புள்ளியில் இருந்து பிழையைப் பார்த்தால், பின்வரும் பிழை அறிக்கையைப் பெறுவீர்கள்.

JavaCodeGeeks.java:8: error: unreachable statement
System.out.println("After break");
                ^
1 error

அறிக்கைகளைத் தொடரவும்

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

public class JavaIsFun
{
    public static void main(String[] args) {
        for(int i=0;i<8;i++)
        {
            System.out.println(i);
            if(i==5)
            {
                continue;
                System.out.println("Coding after continue");
            }
        }
    }
}

கணினி உங்கள் “தொடர்ச்சிக்குப் பிறகு கோடிங்” அறிக்கையை இயக்காது - கம்பைலர் அதைப் பற்றி உடனடியாக உங்களுக்குத் தெரிவிக்கும்.

JavaIsFun.java:10: error: unreachable statement
                                System.out.println("Coding after continue");

எல்லையற்ற சுழல்கள்

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

public class JavaCodeGym
{
    public static void main(String[] args) {
        while(true)
        {
            System.out.println("Hey there");
        }
        System.out.println("Nice to see you");
    }
}

பிழை எங்கே மறைந்துள்ளது என்று யூகிக்க முடியுமா? உங்கள் குறியீட்டை இயக்கியவுடன் கம்பைலர் அதை உடனே சுட்டிக்காட்டும்:

//unreachable code statement compiler error
JavaCodeGym.java:10: error: unreachable statement
                System.out.println("Nice to see you");
‘

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

முடிவுரை

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