En uopnåelig kodesætning er et almindeligt problem blandt Java-begyndere. Mange nybegyndere forveksler fejlen med "død kode" - et andet Java-relateret fænomen. Selvom de to er ens ved manifestation, er der nogle forskelle, som vi vil dække i dette indlæg. Bortset fra det, vil du finde ud af, hvad de mest almindelige årsager til, at din compiler returnerer en uopnåelig kodesætning er, og opdage nogle nemme rettelser til at få din kode op at køre igen.
Hvad er uopnåelig kode?
Per definition er en uopnåelig sætning den, der ikke vil blive eksekveret af en compiler, når du kører klar-til-deploy kode. En uopnåelig koderetursætning er typisk et tegn på en logisk fejl i programmet. Selvom der er flere grunde til, at du ender med en sådan erklæring, er uopnåelig kode i alle tilfælde overflødig, roder dit program og bør undgås for enhver pris.
Uopnåelig kode vs død kode
I udviklingssamfundet er begreberne "uopnåelig" og "død" kode praktisk talt synonyme. Men hvis du er kræsen, når du læser dokumentationen, kan du måske se, at udviklingsvejledninger ofte nævner de to hver for sig. Er der nogen forskel mellem død og utilgængelig kode? Grundlæggende er forskellen mellem de to fejl i den måde, compileren reagerer på dem. Hvis koden, du indtaster i compileren, ikke kan nås , får du en kompilerings-runtime-fejl i Java-meddelelse. Hvis din erklæring er " død kode ", vil der ikke være nogen runtime fejl - en udvikler 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
}
}
Da der ikke er nogen direkte compilerfejl i tilfælde af død kode, er det sværere at opdage. Men hvis du holder omhyggelig styr på System.out.printIn returnerer, bør det ikke give dig problemer at fange død kode.
Hvorfor du får uopnåelige kodeerklæringer
Den gode nyhed er, at det er nemt at spore årsagen til uopnåelige kodeproblemer. Der er tre hovedårsager til, at din compiler bliver ved med at returnere fejl:
Overførselsopgørelser. Hvis du bryder din kode med en return-sætning, vil intet efter "return = true" blive udført.
Uendelig sløjfe - ingen kode du skrev efter den uendelige løkke vil heller blive udført, da systemet bliver ved med at gentage løkkehandlingen. Når du konverterer din kode til byte-kode, vil compileren således sende en uopnåelig kodefejl.
Lad os zoome ind på dem for at hjælpe dig med at markere og løse disse problemer.
Returerklæringer
En returerklæring er en del af søgeordsgruppen Overfør, hvilket betyder, at den afslutter din metode. Det er nyttigt til at adskille funktioner og hjælper med at holde din kode læsbar og ren. Men da du ikke kan tilføje nye udsagn til funktionen efter return = true, vil et forsøg på at fortsætte funktionen efter nøgleordet give dig en "Unåeligt kode"-kompilerfejl. Lad os tage et kig på et eksempel på "return = sand" fejlhåndtering og den måde en compiler 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");
}
}
Sådan vil en returerklæringsmisbrug blive vist i compileren:
For at styrke det, du har lært, foreslår vi, at du ser en videolektion fra vores Java-kursus
Bryd udtalelser
Break statements er en anden type søgeord, du skal være forsigtig med, når du skriver Java-funktioner. Ifølge definitionen bruges nøgleordet break til at afslutte en løkke. I eksemplet nedenfor, når en udvikler forlader sløjfen, vil han ikke længere være i stand til at udføre sætningen på linje 8 - således vil compileren vise en uopnåelig sætningsfejl. Her er eksempelkoden, der vil resultere i en uopnåelig kodesætning:
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å fejlen fra et compiler-synspunkt, får du følgende fejlsætning.
Continue er et løkkekontrolnøgleord, der bruges til at gentage handlinger. Når du ønsker, at udførelsen af en loop skal starte fra bunden af sig selv, skal du tilføje fortsæt til din kode. Udsagnet er nyttigt til at hjælpe udviklere med at vælge, hvilke udsagn af loopet, de vil gentage, og dem, de ikke ville indsætte i iterationen. Selvom fortsæt er et ligetil nøgleord at bruge, fører ikke det at have fuld forståelse for, hvordan det fungerer, udviklere til "uopnåelig kode"-fælden. Da et system, efter at have stødt på en fortsæt, gentager løkken, vil nøgleordet ikke være i stand til at nå de udsagn, der følger efter det. Lad os sige, 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 udføre din "Coding after continue"-sætning - compileren vil fortælle dig om det med det samme.
JavaIsFun.java:10: error: unreachable statement
System.out.println("Coding after continue");
Uendelige sløjfer
Et scenarie, der ligner eksemplerne på "break" og "continue" søgeordsbrug, er det med en uendelig løkke. Når du designer en uendelig løkke, skal en udvikler huske, at ingen sætning efter den nogensinde vil køre. Således, hvis du ikke bryder løkken, vil al den kode, der er skrevet efter, være utilgængelig. Her er et interessant eksempel på uendelig løkke mishandling at tjekke ud:
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 gætte, hvor fejlen gemmer sig? Compileren vil pege på det med det samme, når du kører din kode:
//unreachable code statement compiler error
JavaCodeGym.java:10: error: unreachable statement
System.out.println("Nice to see you");
‘
Da der er en uendelig løkke før "Dejligt at se dig" , vil sætningen aldrig køre og blive ved med at returnere en uopnåelig kodefejl.
Konklusion
For at undgå uopnåelig kode skal du sørge for, at der er et flow til alle dine systemsætninger. De fleste problemer med Java-uopnåelig kode har at gøre med håndtering af nøgleord og dårlig håndtering af loops. I slutningen af dagen er dobbelttjek af din kode den eneste gennemprøvede måde at undgå uopnåelige kodefejl. Du bør heller ikke blive afskrækket af dem - vanen med at skabe flydende Java-kode kommer med mange års erfaring og praksis. Så lad os trykke på IDE og begynde at bygge fantastiske softwareprodukter.
GO TO FULL VERSION