Java मध्ये पोहोचण्यायोग्य स्टेटमेंट कोड एरर

जावा नवशिक्यांमधील एक अगम्य कोड स्टेटमेंट ही एक सामान्य समस्या आहे. बरेच नवशिक्या डेव्हलपर "डेड कोड" सह त्रुटी गोंधळात टाकतात - दुसरी जावा-संबंधित घटना. जरी दोन्ही प्रकटीकरणानुसार समान आहेत, तरीही काही फरक आहेत जे आम्ही या पोस्टमध्ये कव्हर करू. त्या व्यतिरिक्त, तुमच्या कंपाइलरने अगम्य कोड स्टेटमेंट परत करण्याची सर्वात सामान्य कारणे कोणती आहेत हे तुम्हाला कळेल आणि तुमचा कोड पुन्हा चालू करण्यासाठी काही सोपे निराकरणे शोधा.

अगम्य कोड म्हणजे काय?

व्याख्येनुसार, एक अगम्य विधान असे आहे जे तुम्ही डिप्लॉय-टू-डिप्लॉय कोड चालवता तेव्हा कंपाइलरद्वारे कार्यान्वित केले जाणार नाही. अगम्य कोड रिटर्न स्टेटमेंट हे प्रोग्राममधील लॉजिकल एररचे लक्षण असते. तुम्ही असे विधान का करत आहात याची अनेक कारणे असली तरी, सर्व प्रकरणांमध्ये, पोहोचता न येणारा कोड निरर्थक आहे, तुमच्या प्रोग्राममध्ये गोंधळ घालतो आणि कोणत्याही परिस्थितीत टाळला पाहिजे.

अगम्य कोड वि डेड कोड

विकास समुदायामध्ये, "अगम्य" आणि "मृत" कोडच्या संकल्पना व्यावहारिकदृष्ट्या समानार्थी आहेत. तथापि, दस्तऐवज वाचताना तुम्ही नीटपिक करत असाल तर तुम्हाला दिसेल की विकास मार्गदर्शक तत्त्वे अनेकदा दोन स्वतंत्रपणे नमूद करतात. मृत आणि अगम्य कोडमध्ये काही फरक आहे का? मुळात, दोन त्रुटींमधील फरक कंपायलर त्यांना ज्या प्रकारे प्रतिक्रिया देतो त्यामध्ये आहे. जर तुम्ही कंपाइलरमध्ये प्रविष्ट केलेला कोड अगम्य असेल तर , तुम्हाला Java सूचनेमध्ये संकलित रनटाइम त्रुटी मिळेल. तुमचे स्टेटमेंट “ डेड कोड ” असल्यास , रनटाइम एरर नसतील - डेव्हलपरला खालील सिस्टम चेतावणी मिळेल:

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 रिटर्नचा काळजीपूर्वक मागोवा ठेवत असाल तर , मृत कोड पकडल्याने तुम्हाला त्रास होणार नाही.

तुम्हाला अगम्य कोड स्टेटमेंट का मिळतात

चांगली बातमी अशी आहे की, अगम्य कोड समस्यांचे कारण शोधणे सोपे आहे. तुमचा कंपाइलर एरर परत का ठेवतो याची तीन मुख्य कारणे आहेत:

• स्टेटमेंट हस्तांतरित करा. तुम्ही रिटर्न स्टेटमेंटसह तुमचा कोड खंडित केल्यास, “return = true” नंतर काहीही कार्यान्वित केले जाणार नाही.
• अनंत लूप - अनंत लूप नंतर तुम्ही लिहिलेला कोणताही कोड कार्यान्वित केला जाणार नाही कारण सिस्टीम लूप क्रियेचा पुनरुच्चार करत राहील. अशा प्रकारे, तुमचा कोड बाइट कोडमध्ये रूपांतरित करताना, कंपाइलर एक अगम्य कोड त्रुटी पाठवेल.

तुम्‍हाला या समस्‍या ध्वजांकित करण्‍यात आणि निराकरण करण्‍यात मदत करण्‍यासाठी, चला त्‍यांना झूम इन करू या.

विधाने परत करा

रिटर्न स्टेटमेंट हा ट्रान्सफर कीवर्ड ग्रुपचा एक भाग आहे, याचा अर्थ ते तुमची पद्धत संपुष्टात आणते. हे फंक्शन्स वेगळे करण्यासाठी उपयुक्त आहे आणि तुमचा कोड वाचनीय आणि स्वच्छ ठेवण्यास मदत करते. तथापि, रिटर्न = ट्रू नंतर फंक्शनमध्ये नवीन विधाने जोडू शकत नसल्यामुळे, कीवर्ड नंतर फंक्शन सुरू ठेवण्याचा प्रयत्न केल्यास तुम्हाला “अगम्य कोड” कंपाइलर त्रुटी मिळेल. चला “return = true” चुकीच्या हाताळणीचे उदाहरण आणि कंपायलर त्यावर कशी प्रतिक्रिया देतो ते पाहू.

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

तुम्ही जे शिकलात ते बळकट करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधील व्हिडिओ धडा पाहण्याचा सल्ला देतो

विधाने खंडित करा

ब्रेक स्टेटमेंट्स हे आणखी एक प्रकारचे कीवर्ड आहेत ज्यांची तुम्हाला Java फंक्शन्स लिहिताना काळजी घेणे आवश्यक आहे. व्याख्येनुसार, ब्रेक कीवर्ड लूप समाप्त करण्यासाठी वापरला जातो. खालील उदाहरणात, विकासक लूपमधून बाहेर पडल्यावर, तो यापुढे 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 हा लूप कंट्रोल कीवर्ड क्रियांचा पुनरुच्चार करण्यासाठी वापरला जातो. जेव्हा तुम्हाला लूपची अंमलबजावणी स्वतःपासून सुरू व्हायची असेल, तेव्हा तुमच्या कोडमध्ये सुरू ठेवा. विधान विकासकांना लूपची कोणती विधाने पुनरावृत्ती करायची आहेत आणि ते पुनरावृत्तीमध्ये ठेवणार नाहीत हे निवडण्यात मदत करण्यासाठी उपयुक्त आहे. कंटिन्यू हा वापरण्यासाठी सरळ कीवर्ड असला तरी, ते कसे कार्य करते याची पूर्ण माहिती नसल्यामुळे विकासकांना "अगम्य कोड" ट्रॅपमध्ये नेले जाते. सुरू ठेवल्यानंतर, सिस्टम लूपचा पुनरुच्चार करेल, कीवर्ड त्याचे अनुसरण करणाऱ्या विधानांपर्यंत पोहोचू शकणार नाही. म्हणा, तुमच्याकडे खालील कोड आहे:

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

"तुला पाहून आनंद झाला" च्या आधी एक अनंत लूप असल्याने , विधान कधीही कार्यान्वित होणार नाही आणि अगम्य कोड त्रुटी परत करत राहील.

निष्कर्ष

अगम्य कोड टाळण्यासाठी, तुम्हाला तुमच्या सर्व सिस्टम स्टेटमेंटमध्ये प्रवाह असल्याची खात्री करणे आवश्यक आहे. बर्‍याच Java अगम्य कोड समस्यांचा संबंध कीवर्ड हाताळण्याशी आणि लूप खराबपणे व्यवस्थापित करण्याशी असतो. दिवसाच्या शेवटी, तुमचा कोड दुहेरी-तपासणे हा अगम्य कोड चुका टाळण्यासाठी एकमेव प्रयत्न केलेला आणि खरा मार्ग आहे. तुम्ही त्यांच्याकडून निराश होऊ नका - फ्लुइड Java कोड तयार करण्याची सवय अनेक वर्षांच्या अनुभव आणि सरावाने येते. तर, चला IDE दाबा आणि अप्रतिम सॉफ्टवेअर उत्पादने तयार करण्यास सुरुवात करूया.