Break statement sa Java

Kumusta sa lahat ng mga kasamahan at sa mga simpleng interesado. Ngayon ay titingnan natin ang isang tampok ng Java programming language bilang break operator. Ito ang unang artikulo sa paksa ng mga operator ng paglipat, kaya kung gusto mo ito, ikalulugod kong magsulat ng higit pa. Gusto kong tandaan kaagad na ang artikulong ito ay pangunahing inilaan para sa mga nagsisimulang developer, at ang mga mas advanced na mag-aaral ay maaaring walang mahanap na bago para sa kanilang sarili dito. So, tara na. Sa Java, mayroong 2 paraan upang baguhin ang pagkakasunud-sunod kung saan isinasagawa ang mga tagubilin ng programa: mga jump statement at mekanismo ng exception handling. May tatlong jump operator sa java: break, continue at return. Ngayon inaanyayahan kita na tingnang mabuti ang operator break. Ang paghawak ng eksepsiyon ay napakalawak na paksa na lampas sa saklaw ng artikulong ito. Mayroong tatlong mga paraan upang gamitin ang break na pahayag sa java. Ang una at pinakasikat na paraan ay ang paggamit nito breakupang lumabas nang maaga sa loop, halimbawa:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

Ipapakita ng halimbawang ito ang:

1
2
cycle was finished

Nangangahulugan ito na kapag ang loop counter iay naging katumbas ng naipasa na parameter number, iyon ay, ang numero 3, ang loop execution ay maagang matatapos. Kung ang programa ay may ilang mga nested na mga loop, pagkatapos ay basagin ang mga output mula lamang sa pinakaloob na loop, halimbawa:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

Ang halimbawang ito ay gumagawa ng output:

012
012
012
012
012
cycles was finished

Tulad ng makikita mula sa halimbawa, ang panloob na loop ay nagambala sa bawat oras sa numero 3 (parameter number), at ang panlabas na loop ay isinasagawa ng 5 beses, ayon sa nilalayon. Sa java, maaari kang gumamit ng higit sa isang pahayag ng break sa loob ng isang loop, ngunit hindi ito inirerekomenda, dahil ang pagiging madaling mabasa at istraktura ng code ay lubhang nasiraan ng loob. Ang pangalawang paggamit breakay ang paggamit nito upang matakpan ang pagpapatupad ng mga pahayag sa mga sangay switch, halimbawa:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

Ang pagpapatakbo ng halimbawang ito ay gagawa ng output:

4
after switch

Ang pahayag ng break ay nagpasa ng kontrol sa code kasunod ng buong block switch. Kung hindi mo tinukoy breaksa switchhalimbawang ito:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

Ang output ay hindi magiging tulad ng inaasahan:

4
4
after switch

Nangyari ito dahil pagkatapos na maisakatuparan ang block, case 2ipinagpatuloy ng programa ang pagpapatupad ng lahat ng kasunod na case blocks , na nagbigay sa amin ng kaukulang output. Minsan ang tampok na ito ng operator switch ay maaaring maging kapaki-pakinabang sa amin, halimbawa:

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

Inihahambing ng program na ito ang isang naibigay na numero sa numero 5 at nagbibigay ng sumusunod na output:

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

Kapag tinawag ang isang paraan sa unang pagkakataon, switchinililipat ng operator ang kontrol sa operator case 2at pagkatapos ay sa operator breaksa case 5. Ang pangalawang tawag ay katulad ng una, ngunit nagsisimula sa c case 7. Ang ikatlong tawag ay hindi nakakahanap ng angkop na halaga sa lahat ng mga kaso, kaya ang operator ay pinaandar default. Ang ikatlong paraan ay ang paggamit ng operator breaksa halip na ang gotooperator ng C. Upang gawin ito, gagamit kami ng isang espesyal na anyo ng operator breakna tinatawag breakna may label. Ang form na ito ay mukhang break метка;isang Label - ito ay karaniwang anumang angkop na pangalan mula sa java namespace, bago ang isang bloke ng code. Bukod dito, pagkatapos ilapat ang bloke ng code na ito breakna may label, ang code ay patuloy na isasagawa mula sa lugar pagkatapos ng bloke na may kaukulang label, halimbawa:

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

Ang halimbawang ito ay gagawa ng sumusunod na output:

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

Pagkatapos ng unang paraan ng tawag, inililipat ng operator breakang kontrol sa dulo ng block secondBlock, lalabas secondBlockat thirdBlock, habang nagpapatupad ng isa pang operator println()sa dulo firstBlock. Pagkatapos ng pangalawang tawag, lahat ng linya ay ipinapakita sa screen. Ang mga label ay maaari ding gamitin upang ipahiwatig ang mga cycle. Dapat tandaan na maaari ka lamang pumunta sa isang label mula sa loob ng bloke ng code na ipinahiwatig ng label; halimbawa, ang naturang code ay hindi mag-compile:

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

Mga tala sa code at kalinisan ng pahayag break: Karaniwang tinatanggap ang payo na gamitin ang pahayag breaknang maingat, dahil ang paggamit breakay nagpapahirap sa loop na maunawaan at pinipilit ang programmer na tumingin sa loob ng loop upang maunawaan ang mga nuances ng operasyon nito. Mayroong isang heuristic na panuntunan na break maaari mong gamitin nang mas may kumpiyansa sa mas maiikling mga loop at nang may higit na pag-iingat sa mahaba at malalim na nested na mga loop, dahil pinapataas nito ang posibilidad ng mga error at nagpapakumplikado sa pagbabasa at pag-unawa sa iyong code ng ibang mga programmer. Tulad ng isinulat ko sa itaas, ang paggamit ng isang malaking bilang ng break. na nakakalat sa buong code ay nagpapahiwatig na ang programmer ay hindi lubos na nauunawaan kung bakit niya isinulat ang kanyang code sa paraang ginawa niya. Maaaring sulit na isaalang-alang ang pag-refactor ng naturang loop sa pamamagitan ng paghahati nito sa ilang mas maliliit na loop. Subukang maging maingat kapag gumagamit break ng isang label bilang kapalit para sa goto, dahil ito ay nagpapalubha sa istraktura ng code. Iyon lang ang gusto kong sabihin sa iyo ngayon tungkol sa operator breaksa java. Ako ay natutuwa sa nakabubuo na pagpuna, at handa rin akong magsulat ng isang pagpapatuloy tungkol sa mga operator continueat return, kung ikaw ay interesado.