Uoppnåelig erklæringskodefeil i Java

En uoppnåelig kodesetning er et vanlig problem blant Java-nybegynnere. Mange nybegynnere forveksler feilen med "død kode" - et annet Java-relatert fenomen. Selv om de to er like ved manifestasjon, er det noen forskjeller som vi vil dekke i dette innlegget. Bortsett fra det, vil du finne ut hva de vanligste årsakene til at kompilatoren din returnerer en uoppnåelig kodesetning er, og oppdage noen enkle rettelser for å få koden din opp og kjøre igjen.

Hva er uoppnåelig kode?

Per definisjon er en uoppnåelig setning den som ikke vil bli utført av en kompilator når du kjører klar-til-distribusjon kode. En uoppnåelig koderetursetning er vanligvis et tegn på en logisk feil i programmet. Selv om det er flere grunner til at du ender opp med en slik uttalelse, er uoppnåelig kode i alle tilfeller overflødig, roter til programmet og bør unngås for enhver pris.

Uoppnåelig kode vs død kode

I utviklingssamfunnet er begrepene "uoppnåelig" og "død" kode praktisk talt synonyme. Imidlertid, hvis du er pirkete når du leser dokumentasjonen, kan du kanskje se at retningslinjer for utvikling ofte nevner de to separat. Er det noen forskjell mellom død og uoppnåelig kode? I utgangspunktet er skillet mellom de to feilene i måten kompilatoren reagerer på dem. Hvis koden du skriver inn i kompilatoren ikke kan nås , får du en kompileringskjøringsfeil i Java-varsel. Hvis utsagnet ditt er " død kode ", vil det ikke være noen kjøretidsfeil - en utvikler vil få følgende systemadvarsel:

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

Siden det ikke er noen direkte kompilatorfeil i tilfelle død kode, er det vanskeligere å oppdage. Men hvis du følger nøye med på System.out.printIn- returer, bør det ikke føre til problemer å fange død kode.

Hvorfor du får uoppnåelige kodeerklæringer

Den gode nyheten er at det er enkelt å spore årsaken til uoppnåelige kodeproblemer. Det er tre hovedårsaker til at kompilatoren din fortsetter å returnere feil:

Overføringsoppgaver. Hvis du bryter koden din med en retursetning, vil ingenting etter "return = true" bli utført.
Uendelig sløyfe - ingen kode du skrev etter den uendelige sløyfen vil heller bli utført siden systemet vil fortsette å gjenta sløyfehandlingen. Når du konverterer koden din til bytekode, vil kompilatoren derfor sende en uoppnåelig kodefeil.

For å hjelpe deg med å flagge og fikse disse problemene, la oss zoome inn på dem.

Returner uttalelser

En returerklæring er en del av nøkkelordgruppen Overfør, noe som betyr at den avslutter metoden din. Det er nyttig for å skille funksjoner og bidrar til å holde koden lesbar og ren. Men siden du ikke kan legge til nye utsagn til funksjonen etter return = true, vil det å prøve å fortsette funksjonen etter nøkkelordet gi deg en "Unreachable code"-kompilatorfeil. La oss ta en titt på et eksempel på "return = true" feilhåndtering og måten en kompilator reagerer 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");
    }
}

Slik vil en retursetningsmisbruk vises i kompilatoren:

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

For å forsterke det du lærte, foreslår vi at du ser en videoleksjon fra vårt Java-kurs

Bryt uttalelser

Break-setninger er en annen type nøkkelord du må være forsiktig med når du skriver Java-funksjoner. Per definisjonen brukes nøkkelordet break for å avslutte en loop. I eksemplet nedenfor, når en utvikler går ut av loopen, vil han ikke lenger være i stand til å utføre setningen på linje 8 - dermed vil kompilatoren vise en uoppnåelig setningsfeil. Her er eksempelkoden som vil resultere i en uoppnåelig kodesetning:

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

Ser du på feilen fra et kompilatorsynspunkt, får du følgende feilsetning.

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

Fortsett uttalelser

Continue er et sløyfekontrollnøkkelord som brukes til å gjenta handlinger. Når du vil at kjøringen av en løkke skal starte fra bunnen av av seg selv, legg fortsett til koden din. Uttalelsen er nyttig for å hjelpe utviklere med å velge hvilke utsagn av loopen de vil gjenta og de de ikke ville lagt inn i iterasjonen. Selv om fortsett er et enkelt nøkkelord å bruke, fører ikke det å ha full forståelse for hvordan det fungerer utviklere til fellen "uoppnåelig kode". Siden et system vil gjenta løkken etter å ha møtt en fortsettelse, vil ikke nøkkelordet kunne nå utsagn som følger det. La oss si at du har følgende kode:

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 vil ikke utføre "Coding after continue"-setningen din - kompilatoren vil gi deg beskjed om det med en gang.

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

Uendelige løkker

Et scenario som ligner eksemplene på "bryte" og "fortsett" søkeordbruk, er en uendelig løkke. Når du designer en uendelig sløyfe, bør en utvikler huske at ingen uttalelse etter den noen gang vil kjøre. Dermed, hvis du ikke bryter løkken, vil all koden skrevet etter være utilgjengelig. Her er et interessant eksempel på feilhåndtering av uendelig løkke å sjekke ut:

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 gjette hvor feilen gjemmer seg? Kompilatoren vil peke på det med en gang du kjører koden din:

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

Siden det er en uendelig sløyfe før "Hyggelig å se deg" , vil setningen aldri kjøre og fortsette å returnere en uoppnåelig kodefeil.

Konklusjon

For å unngå uoppnåelig kode, må du sørge for at det er en flyt til alle systemsetningene dine. De fleste problemer med Java-uoppnåelig kode har å gjøre med håndtering av nøkkelord og dårlig håndtering av looper. På slutten av dagen er dobbeltsjekking av koden din den eneste utprøvde måten å unngå uoppnåelige kodefeil. Du bør heller ikke bli motløs av dem - vanen med å lage flytende Java-kode kommer med mange års erfaring og praksis. Så la oss treffe IDE og begynne å bygge fantastiske programvareprodukter.