Elérhetetlen utasításkód hiba a Java-ban

Az elérhetetlen kódutasítás gyakori probléma a Java kezdők körében. Sok kezdő fejlesztő összekeveri a hibát a „halott kóddal” – egy másik, a Java-val kapcsolatos jelenséggel. Bár megnyilvánulásuk szerint a kettő hasonló, van néhány különbség, amelyeket ebben a bejegyzésben tárgyalunk. Ezen kívül megtudhatja, melyek a leggyakoribb okai annak, hogy a fordítója elérhetetlen kódutasítást ad vissza, és felfedezhet néhány egyszerű javítást a kód újraindításához.

Mi az az elérhetetlen kód?

Definíció szerint az elérhetetlen utasítás az, amelyet a fordító nem hajt végre a telepítésre kész kód futtatásakor. Az elérhetetlen kód visszatérési utasítás általában a programon belüli logikai hibára utal. Bár több oka is van annak, hogy miért kap egy ilyen kijelentést, az elérhetetlen kód minden esetben redundáns, összezavarja a programot, és minden áron kerülendő.

Elérhetetlen kód vs holt kód

A fejlesztői közösségben az „elérhetetlen” és a „halott” kód fogalma gyakorlatilag szinonimák. Ha azonban finnyás a dokumentáció olvasásakor, láthatja, hogy a fejlesztési irányelvek gyakran külön említik a kettőt. Van különbség a halott és az elérhetetlen kód között? Alapvetően a két hiba közötti különbség abban rejlik, ahogyan a fordítóprogram reagál rájuk. Ha a fordítóba beírt kód nem érhető el , fordítási futásidejű hibaüzenet jelenik meg a Java értesítésben. Ha az utasítás „ halott kód ”, nem lesznek futásidejű hibák – a fejlesztő a következő rendszerfigyelmeztetést kapja:

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

Mivel halott kód esetén nincs közvetlen fordítóhiba, nehezebb észlelni. Ha azonban gondosan követi a System.out.printIn visszatéréseket, a halott kód elkapása nem okozhat gondot.

Miért kap elérhetetlen kódnyilatkozatokat?

A jó hír az, hogy könnyen nyomon követhető az elérhetetlen kódproblémák oka. Három fő oka van annak, hogy a fordítóprogram folyamatosan hibákat ad vissza:

Átigazolási nyilatkozatok. Ha megtöri a kódot egy return utasítással, akkor a „return = true” után semmi nem hajtódik végre.
Végtelen ciklus – a végtelen ciklus után írt kód sem kerül végrehajtásra, mivel a rendszer folyamatosan megismétli a ciklus műveletét. Így a kód bájtkódra konvertálásakor a fordító elérhetetlen kódhibát küld.

A problémák megjelölése és megoldása érdekében nagyítson rájuk.

Visszaküldési nyilatkozatok

A return utasítás a Transfer kulcsszócsoport része, ami azt jelenti, hogy leállítja a metódust. Hasznos a funkciók szétválasztásában, és segít megőrizni a kód olvashatóságát és tisztaságát. Mivel azonban a return = true után nem adhat hozzá új utasításokat a függvényhez, a kulcsszó utáni függvény folytatása „Elérhetetlen kód” fordítói hibát ad. Vessünk egy pillantást a „return = true” helytelen kezelésre és arra, hogy a fordító hogyan reagál rá.

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

Így jelenik meg a visszatérési utasítás visszaélése a fordítóban:

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

A tanultak megerősítése érdekében javasoljuk, hogy nézzen meg egy videóleckét a Java-tanfolyamról

Kijelentések törése

A törési utasítások egy másik típusú kulcsszavak, amelyekkel óvatosnak kell lenni Java függvények írásakor. A definíció szerint a break kulcsszó a ciklus lezárására szolgál. Az alábbi példában, amikor a fejlesztő kilép a ciklusból, többé nem tudja végrehajtani a 8. sorban lévő utasítást – így a fordító elérhetetlen utasításhibát fog mutatni. Íme a mintakód, amely elérhetetlen kódutasítást eredményez:

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

A hibát fordítói szempontból nézve a következő hibaüzenetet kapjuk.

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

Folytassa az állításokat

A Continue egy ciklusvezérlő kulcsszó, amelyet a műveletek megismétlésére használnak. Ha azt szeretné, hogy egy ciklus végrehajtása a nulláról induljon el, adja hozzá a kódhoz a folytatást. Az utasítás hasznos, hogy segítse a fejlesztőket annak kiválasztásában, hogy a ciklus mely utasításait kívánják megismételni, és melyeket nem tennék be az iterációba. Noha a továbbra is egyszerűen használható kulcsszó, a működésének teljes megértése az „elérhetetlen kód” csapdájához vezeti a fejlesztőket. Mivel a folytatás találkozása után a rendszer megismétli a ciklust, a kulcsszó nem fogja tudni elérni az azt követő utasításokat. Tegyük fel, hogy a következő kóddal rendelkezik:

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

A rendszer nem hajtja végre a „Kódolás a folytatás után” utasítást – a fordító azonnal értesíti Önt erről.

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

Végtelen hurkok

A „break” és a „continue” kulcsszóhasználati esetekhez hasonló forgatókönyv egy végtelen ciklus. Amikor egy végtelen ciklust tervez, a fejlesztőnek emlékeznie kell arra, hogy az utána semmilyen utasítás nem fut le. Így, ha nem töri meg a ciklust, az összes utána írt kód elérhetetlen lesz. Itt van egy érdekes példa a végtelen hurok helytelen kezelésére, amelyet érdemes megnézni:

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

Kitalálod, hol rejtőzik a hiba? A fordító azonnal rámutat a kód futtatása után:

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

Mivel a "Örülök, hogy látlak" előtt egy végtelen ciklus van , az utasítás soha nem fut le, és folyamatosan elérhetetlen kódhibát ad vissza.

Következtetés

Az elérhetetlen kód elkerülése érdekében meg kell győződnie arról, hogy az összes rendszerutasításhoz van áramlás. A legtöbb Java elérhetetlen kóddal kapcsolatos probléma a kulcsszavak kezelésével és a hurkok rossz kezelésével kapcsolatos. A nap végén a kód kétszeri ellenőrzése az egyetlen jól bevált módszer az elérhetetlen kódhibák elkerülésére. Ezek sem csüggedhetnek el – a gördülékeny Java kódok készítésének szokása sokéves tapasztalattal és gyakorlattal jár. Tehát csapjunk be az IDE-be, és kezdjük el a fantasztikus szoftvertermékek építését.