जावा में अगम्य कथन कोड त्रुटि

जावा शुरुआती लोगों के बीच एक अगम्य कोड स्टेटमेंट एक आम समस्या है। बहुत सारे नौसिखिए डेवलपर्स "मृत कोड" के साथ त्रुटि को भ्रमित करते हैं - एक अन्य जावा-संबंधित घटना। हालाँकि दोनों दिखने में समान हैं, फिर भी कुछ अंतर हैं जिन्हें हम इस पोस्ट में शामिल करेंगे। इसके अलावा, आपको पता चल जाएगा कि आपके कंपाइलर द्वारा अगम्य कोड स्टेटमेंट लौटाने के सबसे सामान्य कारण क्या हैं और अपने कोड को फिर से चलाने के लिए कुछ आसान सुधारों की खोज करें।

अगम्य कोड क्या है?

परिभाषा के अनुसार, एक अगम्य कथन वह है जिसे एक संकलक द्वारा निष्पादित नहीं किया जाएगा जब आप रेडी-टू-तैनाती कोड चलाते हैं। एक अगम्य कोड रिटर्न स्टेटमेंट आमतौर पर प्रोग्राम के भीतर एक तार्किक त्रुटि का संकेत है। यद्यपि कई कारण हैं कि आप इस तरह के बयान के साथ क्यों समाप्त होते हैं, सभी मामलों में, अगम्य कोड बेमानी है, आपके कार्यक्रम को अव्यवस्थित करता है, और हर कीमत पर इससे बचा जाना चाहिए।

अगम्य कोड बनाम डेड कोड

विकास समुदाय में, "पहुंच योग्य" और "मृत" कोड की अवधारणा व्यावहारिक रूप से पर्यायवाची हैं। हालाँकि, यदि आप दस्तावेज़ पढ़ते समय नाइटपिक हैं तो आप देख सकते हैं कि विकास दिशानिर्देश अक्सर दोनों का अलग-अलग उल्लेख करते हैं। क्या मृत और अगम्य कोड के बीच कोई अंतर है? मूल रूप से, दो त्रुटियों के बीच का अंतर संकलक द्वारा उन पर प्रतिक्रिया करने के तरीके में है। यदि आपके द्वारा कंपाइलर में डाला गया कोड अगम्य है , तो आपको जावा सूचना में संकलन रनटाइम त्रुटि मिलेगी। यदि आपका कथन " मृत कोड " है, तो कोई रनटाइम त्रुटियाँ नहीं होंगी - एक डेवलपर को निम्नलिखित सिस्टम चेतावनी मिलेगी:

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

बयान जारी रखें

जारी रखें एक लूप कंट्रोल कीवर्ड है जिसका उपयोग क्रियाओं को दोहराने के लिए किया जाता है। जब भी आप चाहते हैं कि लूप का निष्पादन अपने आप शुरू से शुरू हो, तो अपने कोड में जारी रखें जोड़ें। डेवलपर्स को यह चुनने में मदद करने के लिए बयान उपयोगी है कि वे लूप के कौन से बयान दोहराना चाहते हैं और जिन्हें वे पुनरावृत्ति में नहीं डालेंगे। हालांकि जारी रखना उपयोग करने के लिए एक सीधा-सादा कीवर्ड है, यह कैसे काम करता है, इसकी पूरी समझ नहीं होने से डेवलपर्स "पहुंच योग्य कोड" जाल में फंस जाते हैं। चूंकि, एक निरंतरता का सामना करने के बाद, एक सिस्टम लूप को दोहराएगा, कीवर्ड इसके बाद आने वाले बयानों तक नहीं पहुंच पाएगा। कहो, आपके पास निम्न कोड है:

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");
‘

चूंकि "आपको देखकर अच्छा लगा" से पहले एक अनंत लूप है , इसलिए कथन कभी भी निष्पादित नहीं होगा और एक अगम्य कोड त्रुटि लौटाता रहेगा।

निष्कर्ष

अगम्य कोड से बचने के लिए, आपको यह सुनिश्चित करने की आवश्यकता है कि आपके सभी सिस्टम स्टेटमेंट में प्रवाह हो। अधिकांश जावा अगम्य कोड मुद्दों को कीवर्ड को संभालने और लूप को खराब तरीके से प्रबंधित करने के साथ करना पड़ता है। दिन के अंत में, अगम्य कोड गलतियों से बचने के लिए अपने कोड की दोबारा जांच करना एकमात्र आजमाया हुआ और सही तरीका है। आपको उनसे निराश भी नहीं होना चाहिए - द्रव जावा कोड बनाने की आदत वर्षों के अनुभव और अभ्यास के साथ आती है। तो, आइए आईडीई पर जाएं और शानदार सॉफ्टवेयर उत्पादों का निर्माण शुरू करें।