Oåtkomligt meddelandekodfel i Java

En oåtkomlig kodsats är ett vanligt problem bland Java-nybörjare. Många nybörjare förväxlar felet med "död kod" - ett annat Java-relaterat fenomen. Även om de två är lika genom manifestation, finns det några skillnader som vi kommer att täcka i det här inlägget. Förutom det kommer du att ta reda på vilka de vanligaste orsakerna till att din kompilator returnerar en kodsats som inte går att nå och upptäcka några enkla korrigeringar för att få igång din kod igen.

Vad är Unreachable Code?

Per definition är en oåtkomlig sats den som inte kommer att exekveras av en kompilator när du kör färdig att distribuera kod. En oåtkomlig kodretursats är vanligtvis ett tecken på ett logiskt fel i programmet. Även om det finns flera anledningar till att du slutar med ett sådant uttalande, är oåtkomlig kod i alla fall överflödig, stör ditt program och bör undvikas till varje pris.

Oåtkomlig kod vs död kod

I utvecklingsgemenskapen är begreppen "oåtkomlig" och "död" kod praktiskt taget synonyma. Men om du är kräsen när du läser dokumentationen kanske du ser att utvecklingsriktlinjer ofta nämner de två separat. Finns det någon skillnad mellan död och oåtkomlig kod? I grund och botten är skillnaden mellan de två felen i hur kompilatorn reagerar på dem. Om koden du anger i kompilatorn inte går att nå , får du ett kompileringsfel i Java-meddelandet. Om ditt uttalande är " död kod " kommer det inte att finnas några körtidsfel - en utvecklare får följande systemvarning:

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

Eftersom det inte finns något direkt kompilatorfel i fallet med död kod, är det svårare att upptäcka. Men om du håller noggrann reda på System.out.printIn- returerna bör det inte orsaka problem att fånga död kod.

Varför du får oåtkomliga koduttalanden

Den goda nyheten är att det är lätt att spåra orsaken till oåtkomliga kodproblem. Det finns tre huvudorsaker till varför din kompilator fortsätter att returnera fel:

Överföringsutlåtanden. Om du bryter din kod med en retursats, kommer ingenting efter "return = true" att exekveras.
Oändlig loop - ingen kod du skrev efter den oändliga loopen kommer heller att exekveras eftersom systemet kommer att fortsätta att upprepa loopåtgärden. Sålunda, när du konverterar din kod till bytekod, kommer kompilatorn att skicka ett kodfel som inte går att nå.

För att hjälpa dig flagga och åtgärda dessa problem, låt oss zooma in på dem.

Returnera uttalanden

En retursats är en del av nyckelordsgruppen Transfer, vilket betyder att den avslutar din metod. Det är användbart för att separera funktioner och hjälper till att hålla din kod läsbar och ren. Men eftersom du inte kan lägga till nya påståenden till funktionen efter return = true, kommer du att försöka fortsätta med funktionen efter nyckelordet ge dig ett kompilatorfel "Unreachable code". Låt oss ta en titt på ett exempel på "retur = sant" felhantering och hur en kompilator reagerar på det.

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

Så här kommer ett missbruk av retursatsen att visas i kompilatorn:

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

För att förstärka det du lärde dig föreslår vi att du tittar på en videolektion från vår Java-kurs

Bryt uttalanden

Break-satser är en annan typ av nyckelord du måste vara försiktig med när du skriver Java-funktioner. Enligt definitionen används nyckelordet break för att avsluta en loop. I exemplet nedan, när en utvecklare lämnar loopen, kommer han inte längre att kunna exekvera satsen på rad 8 - kompilatorn kommer därför att visa ett satsfel som inte går att nå. Här är exempelkoden som kommer att resultera i en oåtkomlig kodsats:

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

Om du tittar på felet från en kompilatorsynpunkt får du följande felsats.

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

Fortsätt uttalanden

Continue är ett nyckelord för loopkontroll som används för att upprepa åtgärder. Närhelst du vill att exekveringen av en loop ska börja från början av sig själv, lägg till fortsätt i din kod. Uttalandet är användbart för att hjälpa utvecklare att välja vilka påståenden i loopen de vill upprepa och de de inte skulle lägga i iterationen. Även om fortsätt är ett enkelt nyckelord att använda, leder inte ha full förståelse för hur det fungerar utvecklare till fällan "oåtkomlig kod". Eftersom, efter att ha stött på en fortsättning, kommer ett system att upprepa loopen, kommer nyckelordet inte att kunna nå de påståenden som följer det. Säg att du har följande kod:

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

Systemet kommer inte att köra din "Coding after continue"-sats - kompilatorn kommer att meddela dig om det direkt.

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

Oändliga slingor

Ett scenario som liknar exemplen på "bryta" och "fortsätt" nyckelordsanvändning är det med en oändlig loop. När du designar en oändlig loop bör en utvecklare komma ihåg att inget uttalande efter det någonsin kommer att köras. Således, om du inte bryter slingan, kommer all kod som skrivs efter att vara oåtkomlig. Här är ett intressant exempel på oändlig slingfel att kolla in:

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

Kan du gissa var felet gömmer sig? Kompilatorn pekar på det direkt när du kör din kod:

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

Eftersom det finns en oändlig loop före "Trevligt att se dig" kommer satsen aldrig att köras och fortsätter att returnera ett oåtkomligt kodfel.

Slutsats

För att undvika oåtkomlig kod måste du se till att det finns ett flöde till alla dina systemsatser. De flesta problem med Java-kod som inte kan nås har att göra med att hantera nyckelord och hantera loopar dåligt. I slutet av dagen är dubbelkontroll av din kod det enda beprövade sättet att undvika oåtkomliga kodmisstag. Du bör inte avskräckas av dem heller - vanan att skapa flytande Java-kod kommer med år av erfarenhet och övning. Så, låt oss slå IDE och börja bygga fantastiska mjukvaruprodukter.