CodeGym /Java Blog /Random /Ang Pahayag na Habang
John Squirrels
Antas
San Francisco

Ang Pahayag na Habang

Nai-publish sa grupo
Ang aming pinakaunang mga programa ay isang pagkakasunod-sunod ng mga tagubilin na isa-isang isinasagawa. Walang tinidor. Kabilang dito ang HelloWorld, na nagpapakita ng pagbati. Kasama dito ang mga kalkulasyon ng aritmetika. Pagkatapos ng aming mga unang programa, natutunan namin kung paano magsangay, ibig sabihin, kung paano gumawa ng isang programa na magsagawa ng iba't ibang mga aksyon depende sa mga partikular na kondisyon. Narito ang code para sa pagkontrol ng central heating at air conditioning system:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();
Gawin ang susunod na hakbang. Sa pang-araw-araw na buhay, madalas kaming nagsasagawa ng pare-parehong paulit-ulit na pagkilos, halimbawa, pagbabalat ng mga mansanas para sa isang pie. Ang kamangha-manghang prosesong ito ay maaaring ilarawan bilang:
  1. Kung may mga mansanas sa mangkok, pagkatapos ay isinasagawa namin ang mga hakbang 1.1 hanggang 1.4:

    1. 1.1. Kumuha ng mansanas
    2. 1.2. Balatan ito at gupitin sa hiwa
    3. 1.3. Ayusin ang mga hiwa ng mansanas sa pie crust sa isang kawali
    4. 1.4. Bumalik sa hakbang 1.
Ang pahayag habang - 2Sabihin nating mayroon kang sampung mansanas, dalawang kamay, at isang kutsilyo. Sa totoong buhay, sunud-sunod mong binabalatan ang buong dosena, na sinusunod ang parehong algorithm para sa bawat mansanas. Ngunit paano namin gagawin ang isang programa na gumawa ng paulit-ulit na aksyon para sa bawat mansanas?
  • Itinatali namin ang aming sarili sa bilang ng mga mansanas, ngunit kung wala kaming sapat na mga ito, ang ilan sa mga utos ay isasakatuparan nang walang "payload" (at maaari naming putulin ang aming sarili habang sinusubukang magbalat ng hindi umiiral na mansanas).
  • Kung mayroong higit pang mga mansanas kaysa sa mga utos na balatan, ang ilan sa mga mansanas ay maiiwan na hindi nababalatan.
  • Ang ganitong code ay mahirap basahin. Marami itong pag-uulit at mahirap baguhin.

Ang mga loop ay mga pahayag na nagpapahintulot sa mga aksyon na maisagawa nang paulit-ulit

Ang while loop ng Java ay gagana nang maayos sa aming kaso. Ang construct na ito ay naglalagay ng maraming aksyon sa isang maigsi at naiintindihan na istraktura. Gamit ang isang while loop, maaaring ganito ang hitsura ng isang apple-slicing algorithm para sa isang pie sa Java:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

Command syntax

Ang unang variant ng while statement ay ganito:

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
Narito ang isang sunud-sunod na paliwanag kung ano ang mangyayari kapag ang code na ito ay naisakatuparan:
  1. Sinusuri namin ang Boolean expression na matatagpuan sa mga panaklong pagkatapos ng while na keyword.
  2. Kung ang Boolean expression ay nagsusuri sa true, ang mga pahayag sa loop body ay isasagawa. Matapos maisakatuparan ang huling pahayag sa katawan ng loop, pagkatapos ay pumunta tayo sa hakbang 1
  3. Kung ang expression ng Boolean ay naging false, pagkatapos ay tumalon kami sa unang pahayag pagkatapos ng while loop.

Loop na may precondition

Dahil palagi naming sinusuri ang Boolean expression (ang kundisyon para sa pagpasok sa loop) bago namin isagawa ang loop body, ang form na ito ng while loop ay madalas na tinatawag na loop na may precondition . Bumuo tayo ng talahanayan ng unang sampung kapangyarihan ng isang numero:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}
Output ng console:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Loop na may postcondition

Narito ang pangalawang variant ng loop na ito:

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Narito ang isang paliwanag kung ano ang mangyayari kapag ang code na ito ay naisakatuparan:
  1. Ang loop body ay isinasagawa (kaagad pagkatapos ng do keyword).
  2. Sinusuri namin ang Boolean expression na matatagpuan sa mga panaklong pagkatapos ng while na keyword.
  3. Kung ang expression ng Boolean ay magiging totoo, pagkatapos ay pupunta tayo sa hakbang 1
  4. Kung ang expression ng Boolean ay naging false, pagkatapos ay tumalon kami sa unang pahayag pagkatapos ng while loop.
Ang dalawang pangunahing pagkakaiba mula sa nakaraang loop ay: 1) ang loop body ay pinaandar nang hindi bababa sa isang beses at 2) ang Boolean expression ay sinusuri pagkatapos na ang loop body ay naisakatuparan. Alinsunod dito, ang ganitong uri ng while loop ay tinatawag na loop na may postcondition . Sa pagkakataong ito, magpapakita kami ng talahanayan ng mga kapangyarihan ng isang numero na hindi lalampas sa 10000:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = base; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * base;
    } while (result < 10000); // The condition for exiting the loop
}
Output ng console:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
Bigyang-pansin ang mga pagbabago sa code. Ihambing ito sa loop na may precondition.

Mga kagiliw-giliw na katotohanan tungkol sa pagtatrabaho sa mga loop

Mga sumasanga na pahayag sa loob ng loop body

Mayroong dalawang pahayag na nakakaapekto sa pagpapatupad sa loob ng isang loop: break (na tatalakayin natin nang mas detalyado sa susunod na kabanata) at magpatuloy.
  • continue — nilaktawan ang pagpapatupad ng natitirang bahagi ng loop body sa kasalukuyang pag-ulit at tumalon sa pagsusuri ng Boolean expression ng while statement. Kung ang expression ay nasuri sa true, pagkatapos ay ang loop ay magpapatuloy.
  • break — agad na tinatapos ang pagpapatupad ng kasalukuyang pag-ulit at inililipat ang kontrol sa unang pahayag pagkatapos ng loop. Kaya, ang pahayag na ito ay nagtatapos sa pagpapatupad ng kasalukuyang loop. Isasaalang-alang namin ito nang mas detalyado sa susunod na artikulo.
Alalahanin ang aming halimbawa ng prutas. Kung hindi kami sigurado sa kalidad ng mga mansanas, maaari naming baguhin ang code gamit ang isang continue statement:

while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}
Ang continue statement ay kadalasang ginagamit kapag ang mga statement sa loop body ay kailangang isagawa kung ang isang partikular na kundisyon ay nasiyahan. Halimbawa, maaaring gusto naming magsagawa ng mga pagkilos kapag na-trigger ang isang sensor ng hardware (kung hindi, ipagpatuloy lang ang loop kung saan kumukuha kami ng mga pagbabasa ng sensor) o maaaring gusto naming kalkulahin ang isang expression sa ilang partikular na pag-ulit ng isang loop. Ang isang halimbawa ng huling kaso ay makikita sa aming paggamit ng isang while loop upang kalkulahin ang kabuuan ng mga cube ng mga natural na numero na ang parisukat ay mas mababa sa bilang ng mga numero. nalilito? Tingnan ang sumusunod na code:

public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

Walang katapusang loop

Ang mga sumasanga na pahayag na ito ay kadalasang ginagamit sa walang katapusang mga loop. Tinatawag namin ang isang loop na walang hanggan kung ang kondisyon ng Boolean para sa pag-alis sa loop ay hindi kailanman nasisiyahan. Sa code, mukhang ganito:

while (true) {
    // Loop body 
}
Sa kasong ito, ang isang break na pahayag ay tumutulong sa amin na lumabas sa loop. Ang ganitong uri ng loop ay angkop kapag naghihintay para sa mga panlabas na kondisyon na tinutukoy sa labas ng katawan ng loop. Halimbawa, sa mga operating system o laro (ang paglabas sa loop ay nangangahulugan ng paglabas sa laro). O kapag gumagamit ng mga algorithm na sumusubok, sa bawat pag-ulit ng isang loop, upang mapabuti ang ilang resulta, ngunit nililimitahan ang bilang ng mga pag-ulit batay sa lumipas na oras o ang paglitaw ng isang panlabas na kaganapan (hal. mga checker, chess, o pagtataya ng panahon). Tandaan na sa ilalim ng normal na mga kondisyon walang katapusan na mga loop ay hindi kanais-nais. Upang ipakita, bumalik tayo sa exponentiation:

public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}
Output ng console:

3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

Mga nested na loop

At ngayon ay dumating kami sa aming huling paksa sa mga loop. Alalahanin ang apple pie na iyon (sana hindi ka nagugutom sa ngayon) at ang aming apple-peeling loop:
  1. Kung may mga mansanas sa mangkok, pagkatapos ay isinasagawa namin ang mga hakbang 1.1 hanggang 1.4:

    1. 1.1. Kumuha ng mansanas
    2. 1.2. Balatan ito at gupitin sa hiwa
    3. 1.3. Ayusin ang mga hiwa ng mansanas sa pie crust sa isang kawali
    4. 1.4. Bumalik sa hakbang 1.
Ilarawan natin ang proseso ng paghiwa nang mas detalyado:
  1. Bilang ng mga hiwa = 0
  2. Hangga't ang bilang ng mga hiwa ay < 12, pagkatapos ay gawin ang mga hakbang 2.1 hanggang 2.3

    1. 2.1. Gupitin ang isa pang hiwa sa mansanas
    2. 2.2. Bilang ng mga hiwa++
    3. 2.3. Bumalik sa hakbang 2
At idaragdag namin ito sa aming algorithm sa paggawa ng pie:
  1. Kung may mga mansanas sa mangkok, pagkatapos ay isinasagawa namin ang mga hakbang 1.1 hanggang 1.6:

    1. 1.1. Kumuha ng mansanas
    2. 1.2. Balatan ito
    3. 1.3. Bilang ng mga hiwa = 0
    4. 1.4. Hangga't ang bilang ng mga hiwa ay < 12, pagkatapos ay gawin ang mga hakbang 1.4.1 hanggang 1.4.3
      1. 1.4.1. Gupitin ang isa pang hiwa sa mansanas
      2. 1.4.2. Bilang ng mga hiwa++
      3. 1.4.3. Bumalik sa hakbang 1.4
    5. 1.5. Ayusin ang mga hiwa ng mansanas sa pie crust sa isang kawali
    6. 1.6. Bumalik sa hakbang 1.
Ngayon mayroon kaming isang loop sa loob ng isang loop. Ang mga konstruksyon na tulad nito ay karaniwan. Bilang huling halimbawa, buuin natin ang isa sa mga multiplication table na natutunan nating mahalin noong elementarya.

 public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9"); 
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j < 10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product < 10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
Output ng console:

    2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Ang mga loop (sa partikular, ang while statement) ay isa sa mga pangunahing gusali ng software. Sa pamamagitan ng paglutas ng mga gawain sa CodeGym, matututunan mo ang lahat ng iba't ibang uri ng mga loop, mauunawaan ang kanilang mga intricacies, at makakuha ng mga praktikal na kasanayan sa paggamit ng mga ito.
Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION