Een onbereikbare codeverklaring is een veelvoorkomend probleem bij Java-beginners. Veel beginnende ontwikkelaars verwarren de fout met "dode code" - een ander Java-gerelateerd fenomeen. Hoewel de twee qua manifestatie vergelijkbaar zijn, zijn er enkele verschillen die we in dit bericht zullen behandelen. Verder zult u ontdekken wat de meest voorkomende redenen zijn waarom uw compiler een onbereikbare code-instructie retourneert en enkele eenvoudige oplossingen ontdekken om uw code weer aan de praat te krijgen.
Wat is een onbereikbare code?
Een onbereikbare instructie is per definitie de instructie die niet wordt uitgevoerd door een compiler wanneer u kant-en-klare code uitvoert. Een onbereikbare code return statement is typisch een teken van een logische fout binnen het programma. Hoewel er verschillende redenen zijn waarom u een dergelijke verklaring krijgt, is onbereikbare code in alle gevallen overbodig, maakt uw programma onoverzichtelijk en moet koste wat het kost worden vermeden.
Onbereikbare code versus dode code
In de ontwikkelingsgemeenschap zijn de concepten "onbereikbare" en "dode" code praktisch synoniem. Als u echter een muggenzifter bent bij het lezen van de documentatie, ziet u misschien dat ontwikkelingsrichtlijnen de twee vaak afzonderlijk vermelden. Is er een verschil tussen dode en onbereikbare code? In wezen zit het onderscheid tussen de twee fouten in de manier waarop de compiler erop reageert. Als de code die u invoert in de compiler onbereikbaar is , krijgt u een compileerruntimefout in de Java-melding. Als uw verklaring " dode code " is, zullen er geen runtime-fouten zijn - een ontwikkelaar krijgt de volgende systeemwaarschuwing:
class DeadCode {
void deadcode_Method(boolean b) {
System.out.println("Reachable statement");
if(true) {
return;
}
System.out.println("Unreachable statement"); // dead code
}
}
Aangezien er geen directe compilerfout is in het geval van dode code, is het moeilijker te detecteren. Als u echter nauwkeurig de retourzendingen van System.out.printIn bijhoudt , zou het opsporen van dode code u geen problemen moeten bezorgen.
Waarom u onbereikbare codeverklaringen krijgt
Het goede nieuws is dat het gemakkelijk is om de oorzaak van onbereikbare codeproblemen op te sporen. Er zijn drie hoofdredenen waarom uw compiler fouten blijft retourneren:
Afschriften overmaken. Als u uw code breekt met een return-statement, wordt niets na "return = true" uitgevoerd.
Oneindige lus - er wordt ook geen code uitgevoerd die u na de oneindige lus hebt geschreven, aangezien het systeem de lusactie blijft herhalen. Dus bij het omzetten van uw code in bytecode, zal de compiler een onbereikbare codefout verzenden.
Laten we erop inzoomen om u te helpen deze problemen te signaleren en op te lossen.
Retour verklaringen
Een return-instructie maakt deel uit van de trefwoordgroep Transfer, wat betekent dat het uw methode beëindigt. Het is handig voor het scheiden van functies en helpt uw code leesbaar en schoon te houden. Aangezien u echter geen nieuwe instructies aan de functie kunt toevoegen na return = true, zal het proberen de functie na het trefwoord voort te zetten een compilerfout "Onbereikbare code" opleveren. Laten we eens kijken naar een voorbeeld van verkeerd gebruik van "return = true" en de manier waarop een compiler erop reageert.
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");
}
}
Hier ziet u hoe misbruik van een retourverklaring wordt weergegeven in de compiler:
Om te versterken wat je hebt geleerd, raden we je aan een videoles van onze Java-cursus te bekijken
Breek verklaringen
Break-statements zijn een ander type trefwoorden waarmee u voorzichtig moet zijn bij het schrijven van Java-functies. Volgens de definitie wordt het sleutelwoord break gebruikt om een lus te beëindigen. In het onderstaande voorbeeld, als een ontwikkelaar de lus verlaat, zal hij niet langer in staat zijn om de instructie op regel 8 uit te voeren - dus zal de compiler een onbereikbare instructiefout tonen. Hier is de voorbeeldcode die resulteert in een onbereikbare codeverklaring:
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");
}
}
}
Als u de fout bekijkt vanuit het oogpunt van een compiler, krijgt u de volgende foutmelding.
Doorgaan is een luscontrolesleutelwoord dat wordt gebruikt om acties te herhalen. Telkens wanneer u wilt dat de uitvoering van een lus helemaal opnieuw begint, voegt u continue toe aan uw code. De instructie is handig om ontwikkelaars te helpen kiezen welke instructies van de lus ze willen herhalen en welke ze niet in de iteratie willen opnemen. Hoewel doorgaan een eenvoudig trefwoord is om te gebruiken, leidt het niet volledig begrijpen van hoe het werkt ertoe dat ontwikkelaars in de valkuil "onbereikbare code" terechtkomen. Aangezien een systeem, nadat het een continue is tegengekomen, de lus herhaalt, kan het trefwoord de instructies die erop volgen niet bereiken. Stel, je hebt de volgende code:
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");
}
}
}
}
Het systeem zal uw "Coding after continue"-instructie niet uitvoeren - de compiler zal u dit meteen laten weten.
JavaIsFun.java:10: error: unreachable statement
System.out.println("Coding after continue");
Oneindige lussen
Een scenario dat vergelijkbaar is met de voorbeelden van het gebruik van sleutelwoorden 'onderbreken' en 'doorgaan' is dat van een oneindige lus. Bij het ontwerpen van een oneindige lus moet een ontwikkelaar onthouden dat geen enkele instructie erna ooit zal worden uitgevoerd. Dus als u de lus niet verbreekt, is alle code die daarna wordt geschreven onbereikbaar. Hier is een interessant voorbeeld van verkeerd gebruik van oneindige lussen om uit te checken:
public class JavaCodeGym
{
public static void main(String[] args) {
while(true)
{
System.out.println("Hey there");
}
System.out.println("Nice to see you");
}
}
Kun jij raden waar de fout zich verbergt? De compiler zal er meteen naar wijzen zodra u uw code uitvoert:
//unreachable code statement compiler error
JavaCodeGym.java:10: error: unreachable statement
System.out.println("Nice to see you");
‘
Aangezien er een oneindige lus is voorafgaand aan "Nice to see you" , zal de instructie nooit worden uitgevoerd en blijft een onbereikbare codefout terugkeren.
Conclusie
Om onbereikbare code te voorkomen, moet u ervoor zorgen dat er een stroom is naar al uw systeemverklaringen. De meeste Java-onbereikbare codeproblemen hebben te maken met het slecht omgaan met trefwoorden en het slecht beheren van lussen. Aan het einde van de dag is het dubbel controleren van uw code de enige beproefde manier om onbereikbare codefouten te voorkomen. U moet zich er ook niet door laten ontmoedigen - de gewoonte om vloeiende Java-code te maken komt voort uit jarenlange ervaring en oefening. Laten we dus naar de IDE gaan en beginnen met het bouwen van geweldige softwareproducten.
GO TO FULL VERSION