జావాలో చేరుకోలేని స్టేట్‌మెంట్ కోడ్ లోపం

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

చేరుకోలేని కోడ్ అంటే ఏమిటి?

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

చేరుకోలేని కోడ్ vs డెడ్ కోడ్

డెవలప్‌మెంట్ కమ్యూనిటీలో, "అన్ రీచబుల్" మరియు "డెడ్" కోడ్ యొక్క భావనలు ఆచరణాత్మకంగా పర్యాయపదాలు. అయినప్పటికీ, మీరు డాక్యుమెంటేషన్‌ను చదివేటప్పుడు నిస్సత్తువగా ఉంటే, డెవలప్‌మెంట్ మార్గదర్శకాలు తరచుగా రెండింటిని విడివిడిగా పేర్కొనడాన్ని మీరు చూడవచ్చు. చనిపోయిన మరియు చేరుకోలేని కోడ్ మధ్య ఏదైనా తేడా ఉందా? ప్రాథమికంగా, రెండు లోపాల మధ్య వ్యత్యాసం కంపైలర్ వాటికి ప్రతిస్పందించే విధానంలో ఉంటుంది. మీరు కంపైలర్‌లో నమోదు చేసిన కోడ్ చేరుకోలేకపోతే , మీరు 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 రిటర్న్‌లను జాగ్రత్తగా ట్రాక్ చేస్తే, డెడ్ కోడ్‌ను క్యాచ్ చేయడం వలన మీకు ఇబ్బంది ఉండదు.

మీరు ఎందుకు చేరుకోలేని కోడ్ స్టేట్‌మెంట్‌లను పొందుతారు

శుభవార్త ఏమిటంటే, చేరుకోలేని కోడ్ సమస్యల కారణాన్ని కనుగొనడం సులభం. మీ కంపైలర్ లోపాలను చూపుతూ ఉండటానికి మూడు ప్రధాన కారణాలు ఉన్నాయి:

• ప్రకటనలను బదిలీ చేయండి. మీరు రిటర్న్ స్టేట్‌మెంట్‌తో మీ కోడ్‌ను విచ్ఛిన్నం చేస్తే, “తిరిగి = నిజం” తర్వాత ఏదీ అమలు చేయబడదు.
• ఇన్ఫినిట్ లూప్ - సిస్టమ్ లూప్ చర్యను పునరుద్ఘాటిస్తూనే ఉంటుంది కాబట్టి మీరు అనంతమైన లూప్ తర్వాత వ్రాసిన కోడ్ అమలు చేయబడదు. అందువల్ల, మీ కోడ్‌ను బైట్ కోడ్‌లో మార్చేటప్పుడు, కంపైలర్ చేరుకోలేని కోడ్ లోపాన్ని పంపుతుంది.

ఈ సమస్యలను ఫ్లాగ్ చేయడంలో మరియు పరిష్కరించడంలో మీకు సహాయపడటానికి, వాటిని జూమ్ చేయండి.

వాపసు ప్రకటనలు

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

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

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

ముగింపు

చేరుకోలేని కోడ్‌ను నివారించడానికి, మీరు మీ సిస్టమ్ స్టేట్‌మెంట్‌లన్నింటికీ ఒక ఫ్లో ఉందని నిర్ధారించుకోవాలి. చాలా జావా చేరుకోలేని కోడ్ సమస్యలు కీలకపదాలను నిర్వహించడం మరియు లూప్‌లను పేలవంగా నిర్వహించడం వంటి వాటికి సంబంధించినవి. రోజు చివరిలో, చేరుకోలేని కోడ్ తప్పులను నివారించడానికి మీ కోడ్‌ను ఒకటికి రెండుసార్లు తనిఖీ చేయడం ప్రయత్నించిన మరియు నిజమైన మార్గం. మీరు వాటిని చూసి నిరుత్సాహపడకూడదు - ఫ్లూయిడ్ జావా కోడ్‌ని సృష్టించే అలవాటు సంవత్సరాల అనుభవం మరియు అభ్యాసంతో వస్తుంది. కాబట్టి, IDEని నొక్కండి మరియు అద్భుతమైన సాఫ్ట్‌వేర్ ఉత్పత్తులను రూపొందించడం ప్రారంభిద్దాం.