Hindi Maabot na Statement Code Error sa Java

Ang isang hindi maabot na pahayag ng code ay isang karaniwang problema sa mga nagsisimula sa Java. Maraming mga baguhan na developer ang nalilito ang error sa "patay na code" - isa pang kababalaghan na nauugnay sa Java. Kahit na ang dalawa ay magkatulad sa pamamagitan ng pagpapakita, may ilang mga pagkakaiba na tatalakayin natin sa post na ito. Maliban diyan, malalaman mo kung ano ang mga pinakakaraniwang dahilan para sa pagbabalik ng iyong compiler ng hindi maabot na pahayag ng code at matuklasan mo ang ilang madaling pag-aayos upang mapatakbo muli ang iyong code.

Ano ang Unreachable Code?

Sa pamamagitan ng kahulugan, ang isang hindi maabot na pahayag ay ang isa na hindi isasagawa ng isang compiler kapag nagpatakbo ka ng ready-to-deploy na code. Ang isang hindi maabot na pahayag ng pagbabalik ng code ay karaniwang isang tanda ng isang lohikal na error sa loob ng programa. Bagama't may ilang mga dahilan kung bakit napupunta ka sa ganoong pahayag, sa lahat ng kaso, ang hindi maabot na code ay kalabisan, nakakalat sa iyong programa, at dapat na iwasan sa lahat ng mga gastos.

Unreachable Code vs Dead Code

Sa development community, ang mga konsepto ng "unreachable" at "dead" code ay halos magkasingkahulugan. Gayunpaman, kung ikaw ay makulit kapag nagbabasa ng dokumentasyon maaari mong makita na ang mga alituntunin sa pag-unlad ay madalas na binabanggit ang dalawa nang hiwalay. Mayroon bang pagkakaiba sa pagitan ng patay at hindi maabot na code? Karaniwan, ang pagkakaiba sa pagitan ng dalawang pagkakamali ay nasa paraan ng pagtugon ng compiler sa kanila. Kung ang code na inilagay mo sa compiler ay hindi maabot , makakakuha ka ng compile runtime error sa Java notification. Kung ang iyong statement ay " patay na code ", walang mga error sa runtime - makukuha ng developer ang sumusunod na babala ng system:

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

Dahil walang direktang compiler error sa kaso ng dead code, mas mahirap itong matukoy. Gayunpaman, kung maingat mong sinusubaybayan ang mga pagbabalik ng System.out.printIn , hindi dapat magdulot sa iyo ng problema ang paghuli sa dead code.

Bakit Ka Makakakuha ng Mga Pahayag ng Hindi Maabot na Code

Ang magandang balita ay, madaling ma-trace ang sanhi ng hindi maabot na mga isyu sa code. May tatlong pangunahing dahilan kung bakit patuloy na nagbabalik ng mga error ang iyong compiler:

• Mga pahayag ng paglilipat. Kung masira mo ang iyong code gamit ang return statement, wala nang isasagawa pagkatapos ng "return = true".
• Infinite loop - walang code na isinulat mo pagkatapos ng infinite loop na isasagawa dahil patuloy na inuulit ng system ang loop action. Kaya, kapag kino-convert ang iyong code sa byte code, magpapadala ang compiler ng hindi maabot na error sa code.

Upang matulungan kang i-flag at ayusin ang mga isyung ito, i-zoom in natin ang mga ito.

Ibalik ang mga pahayag

Ang isang pahayag sa pagbabalik ay bahagi ng pangkat ng Paglipat ng keyword, ibig sabihin, tinatapos nito ang iyong pamamaraan. Ito ay kapaki-pakinabang para sa paghihiwalay ng mga function at tumutulong na panatilihing nababasa at malinis ang iyong code. Gayunpaman, dahil hindi ka makakapagdagdag ng mga bagong pahayag sa function pagkatapos ng return = true, ang pagsubok na ipagpatuloy ang function pagkatapos ng keyword ay magbibigay sa iyo ng error sa compiler na "Hindi maabot na code". Tingnan natin ang isang halimbawa ng maling paghawak ng “return = true” at ang paraan ng pagtugon ng isang compiler dito.

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

Narito kung paano ipapakita ang maling paggamit ng return statement sa compiler:

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

Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course

Mga pahayag ng break

Ang mga break statement ay isa pang uri ng mga keyword na kailangan mong maging maingat kapag nagsusulat ng mga function ng Java. Sa pamamagitan ng kahulugan, ang break na keyword ay ginagamit upang wakasan ang isang loop. Sa halimbawa sa ibaba, habang ang isang developer ay lumabas sa loop, hindi na niya magagawang isagawa ang pahayag sa linya 8 - kaya, ang compiler ay magpapakita ng hindi maabot na error sa pahayag. Narito ang sample na code na magreresulta sa isang hindi maabot na pahayag ng code:

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

Sa pagtingin sa error mula sa isang compiler point-of-view, makukuha mo ang sumusunod na pahayag ng error.

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

Ipagpatuloy ang mga pahayag

Ang Magpatuloy ay isang loop control na keyword na ginagamit upang ulitin ang mga pagkilos. Sa tuwing gusto mong magsimula ang execution ng loop sa sarili nitong simula, magdagdag ng continue sa iyong code. Ang pahayag ay kapaki-pakinabang upang matulungan ang mga developer na piliin kung aling mga pahayag ng loop ang gusto nilang ulitin at ang mga hindi nila ilalagay sa pag-ulit. Bagama't ang magpatuloy ay isang direktang keyword na gagamitin, ang hindi pagkakaroon ng ganap na pag-unawa sa kung paano ito gumagana ay humahantong sa mga developer sa bitag na "hindi maabot na code." Dahil, pagkatapos makatagpo ng isang magpatuloy, uulitin ng isang system ang loop, hindi maaabot ng keyword ang mga pahayag na sumusunod dito. Sabihin, mayroon kang sumusunod na 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");
            }
        }
    }
}

Hindi isasagawa ng system ang iyong "Coding pagkatapos magpatuloy" na pahayag - ipapaalam sa iyo ng compiler ang tungkol dito kaagad.

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

Walang katapusang mga loop

Ang isang senaryo na katulad ng mga halimbawa ng "break" at "continue" na mga kaso ng paggamit ng keyword ay ang isang walang katapusang loop. Kapag nagdidisenyo ng isang walang katapusang loop, dapat tandaan ng isang developer na walang pahayag pagkatapos nito na tatakbo. Kaya, kung hindi mo masira ang loop, ang lahat ng code na nakasulat pagkatapos ay hindi maabot. Narito ang isang kawili-wiling halimbawa ng infinite loop mishandling upang tingnan:

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

Maaari mo bang hulaan kung saan nagtatago ang error? Ituturo ito kaagad ng compiler sa sandaling patakbuhin mo ang iyong code:

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

Dahil mayroong isang walang katapusang loop bago ang "Nice to see you" , ang statement ay hindi kailanman isasagawa at patuloy na magbabalik ng hindi maabot na error sa code.

Konklusyon

Para maiwasan ang hindi maabot na code, kailangan mong tiyaking may daloy sa lahat ng iyong system statement. Karamihan sa mga isyu sa Java na hindi maabot na code ay may kinalaman sa paghawak ng mga keyword at hindi maayos na pamamahala sa mga loop. Sa pagtatapos ng araw, ang pag-double-check sa iyong code ay ang tanging sinubukan at totoong paraan upang maiwasan ang mga hindi maabot na pagkakamali ng code. Hindi ka rin dapat panghinaan ng loob sa kanila - ang ugali ng paglikha ng tuluy-tuloy na Java code ay kasama ng mga taon ng karanasan at kasanayan. Kaya, pindutin natin ang IDE at simulan ang pagbuo ng mga kahanga-hangang produkto ng software.