Fehler beim nicht erreichbaren Anweisungscode in Java

Eine nicht erreichbare Code-Anweisung ist ein häufiges Problem bei Java-Anfängern. Viele unerfahrene Entwickler verwechseln den Fehler mit „totem Code“ – einem weiteren Java-bezogenen Phänomen. Obwohl sich die beiden in ihrer Erscheinungsform ähneln, gibt es einige Unterschiede, die wir in diesem Beitrag behandeln werden. Darüber hinaus erfahren Sie, was die häufigsten Gründe dafür sind, dass Ihr Compiler eine nicht erreichbare Codeanweisung zurückgibt, und entdecken einige einfache Lösungen, um Ihren Code wieder zum Laufen zu bringen.

Was ist nicht erreichbarer Code?

Per Definition ist eine nicht erreichbare Anweisung eine Anweisung, die von einem Compiler nicht ausgeführt wird, wenn Sie bereit zur Bereitstellung Code ausführen. Eine nicht erreichbare Code-Return-Anweisung ist typischerweise ein Zeichen für einen logischen Fehler im Programm. Obwohl es mehrere Gründe dafür gibt, dass Sie mit einer solchen Anweisung enden, ist unerreichbarer Code in jedem Fall überflüssig, überlastet Ihr Programm und sollte unbedingt vermieden werden.

Nicht erreichbarer Code vs. toter Code

In der Entwicklergemeinschaft sind die Konzepte „nicht erreichbarer“ und „toter“ Code praktisch synonym. Wenn Sie jedoch beim Lesen der Dokumentation pingelig sind, werden Sie möglicherweise feststellen, dass in den Entwicklungsrichtlinien die beiden häufig getrennt erwähnt werden. Gibt es einen Unterschied zwischen totem und nicht erreichbarem Code? Der Unterschied zwischen den beiden Fehlern liegt im Wesentlichen in der Art und Weise, wie der Compiler darauf reagiert. Wenn der Code, den Sie in den Compiler eingeben, nicht erreichbar ist , erhalten Sie in der Java-Benachrichtigung einen Laufzeitfehler bei der Kompilierung. Wenn Ihre Anweisung „ toter Code “ ist, treten keine Laufzeitfehler auf – ein Entwickler erhält die folgende Systemwarnung:

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

Da es bei totem Code keinen direkten Compilerfehler gibt, ist er schwieriger zu erkennen. Wenn Sie jedoch die Rückgaben von System.out.printIn sorgfältig im Auge behalten , sollte Ihnen das Abfangen von totem Code keine Probleme bereiten.

Warum Sie nicht erreichbare Codeanweisungen erhalten

Die gute Nachricht ist, dass es einfach ist, die Ursache von Problemen mit unerreichbarem Code zu ermitteln. Es gibt drei Hauptgründe, warum Ihr Compiler immer wieder Fehler zurückgibt:

• Überweisungsanweisungen. Wenn Sie Ihren Code mit einer Return-Anweisung unterbrechen, wird nach „return = true“ nichts ausgeführt.
• Endlosschleife – Code, den Sie nach der Endlosschleife geschrieben haben, wird ebenfalls nicht ausgeführt, da das System die Schleifenaktion ständig wiederholt. Wenn Sie Ihren Code in Bytecode konvertieren, sendet der Compiler daher einen Fehler wegen nicht erreichbarem Code.

Um Ihnen dabei zu helfen, diese Probleme zu erkennen und zu beheben, schauen wir uns sie genauer an.

Return-Anweisungen

Eine Return-Anweisung ist Teil der Schlüsselwortgruppe „Transfer“, was bedeutet, dass sie Ihre Methode beendet. Es ist hilfreich bei der Trennung von Funktionen und trägt dazu bei, dass Ihr Code lesbar und sauber bleibt. Da Sie der Funktion jedoch nach return = true keine neuen Anweisungen hinzufügen können, erhalten Sie beim Versuch, die Funktion nach dem Schlüsselwort fortzusetzen, einen Compilerfehler „Unerreichbarer Code“. Schauen wir uns ein Beispiel für die falsche Handhabung von „return = true“ und die Art und Weise an, wie ein Compiler darauf reagiert.

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

So wird ein Missbrauch einer Return-Anweisung im Compiler angezeigt:

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

Break-Anweisungen

Break-Anweisungen sind eine weitere Art von Schlüsselwörtern, mit denen Sie beim Schreiben von Java-Funktionen vorsichtig sein müssen. Laut Definition wird das Schlüsselwort break zum Beenden einer Schleife verwendet. Im folgenden Beispiel kann ein Entwickler, wenn er die Schleife verlässt, die Anweisung in Zeile 8 nicht mehr ausführen – daher zeigt der Compiler einen Fehler bei der nicht erreichbaren Anweisung an. Hier ist der Beispielcode, der zu einer nicht erreichbaren Codeanweisung führt:

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

Wenn Sie den Fehler aus Compiler-Sicht betrachten, erhalten Sie die folgende Fehleranweisung.

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

Aussagen fortsetzen

Continue ist ein Schlüsselwort zur Schleifensteuerung, das zum Wiederholen von Aktionen verwendet wird. Wenn Sie möchten, dass die Ausführung einer Schleife von selbst von vorne beginnt, fügen Sie continue zu Ihrem Code hinzu. Die Anweisung ist nützlich, um Entwicklern bei der Auswahl zu helfen, welche Anweisungen der Schleife sie wiederholen möchten und welche nicht in die Iteration eingefügt werden sollen. Obwohl continue ein einfach zu verwendendes Schlüsselwort ist, führt das mangelnde Verständnis seiner Funktionsweise dazu, dass Entwickler in die Falle des „unerreichbaren Codes“ tappen. Da ein System nach dem Erkennen einer Fortsetzung die Schleife wiederholt, kann das Schlüsselwort die darauf folgenden Anweisungen nicht erreichen. Angenommen, Sie haben den folgenden 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");
            }
        }
    }
}

Das System wird Ihre „Coding after continue“-Anweisung nicht ausführen – der Compiler wird Sie sofort darüber informieren.

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

Endlosschleifen

Ein Szenario, das den Beispielen für die Schlüsselwort-Anwendungsfälle „break“ und „continue“ ähnelt, ist das einer Endlosschleife. Beim Entwerfen einer Endlosschleife sollte ein Entwickler bedenken, dass keine Anweisung danach jemals ausgeführt wird. Wenn Sie die Schleife also nicht unterbrechen, ist der gesamte danach geschriebene Code nicht erreichbar. Hier ist ein interessantes Beispiel für die falsche Handhabung einer Endlosschleife:

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

Können Sie erraten, wo sich der Fehler verbirgt? Der Compiler zeigt sofort darauf, sobald Sie Ihren Code ausführen:

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

Da es vor „Schön, Sie zu sehen“ eine Endlosschleife gibt , wird die Anweisung nie ausgeführt und gibt immer wieder einen Fehler wegen nicht erreichbarem Code zurück.

Abschluss

Um nicht erreichbaren Code zu vermeiden, müssen Sie sicherstellen, dass alle Ihre Systemanweisungen fließen. Die meisten Probleme mit nicht erreichbarem Java-Code haben mit der schlechten Handhabung von Schlüsselwörtern und der schlechten Verwaltung von Schleifen zu tun. Letztendlich ist die doppelte Überprüfung Ihres Codes die einzige bewährte Möglichkeit, unerreichbare Codefehler zu vermeiden. Sie sollten sich davon auch nicht entmutigen lassen – die Gewohnheit, flüssigen Java-Code zu erstellen, erfordert jahrelange Erfahrung und Übung. Also lasst uns zur IDE gehen und mit der Entwicklung fantastischer Softwareprodukte beginnen.