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:
Sabihin 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?
magpatuloy.
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:
-
Kung may mga mansanas sa mangkok, pagkatapos ay isinasagawa namin ang mga hakbang 1.1 hanggang 1.4:
- 1.1. Kumuha ng mansanas
- 1.2. Balatan ito at gupitin sa hiwa
- 1.3. Ayusin ang mga hiwa ng mansanas sa pie crust sa isang kawali
- 1.4. Bumalik sa hakbang 1.

- 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:
- Sinusuri namin ang Boolean expression na matatagpuan sa mga panaklong pagkatapos ng while na keyword.
- 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
- 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:
- Ang loop body ay isinasagawa (kaagad pagkatapos ng do keyword).
- Sinusuri namin ang Boolean expression na matatagpuan sa mga panaklong pagkatapos ng while na keyword.
- Kung ang expression ng Boolean ay magiging totoo, pagkatapos ay pupunta tayo sa hakbang 1
- Kung ang expression ng Boolean ay naging false, pagkatapos ay tumalon kami sa unang pahayag pagkatapos ng while loop.
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- 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.
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:-
Kung may mga mansanas sa mangkok, pagkatapos ay isinasagawa namin ang mga hakbang 1.1 hanggang 1.4:
- 1.1. Kumuha ng mansanas
- 1.2. Balatan ito at gupitin sa hiwa
- 1.3. Ayusin ang mga hiwa ng mansanas sa pie crust sa isang kawali
- 1.4. Bumalik sa hakbang 1.
- Bilang ng mga hiwa = 0
-
Hangga't ang bilang ng mga hiwa ay < 12, pagkatapos ay gawin ang mga hakbang 2.1 hanggang 2.3
- 2.1. Gupitin ang isa pang hiwa sa mansanas
- 2.2. Bilang ng mga hiwa++
- 2.3. Bumalik sa hakbang 2
-
Kung may mga mansanas sa mangkok, pagkatapos ay isinasagawa namin ang mga hakbang 1.1 hanggang 1.6:
- 1.1. Kumuha ng mansanas
- 1.2. Balatan ito
- 1.3. Bilang ng mga hiwa = 0
- 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.4.1. Gupitin ang isa pang hiwa sa mansanas
- 1.4.2. Bilang ng mga hiwa++ 1.4.3. Bumalik sa hakbang 1.4
- 1.5. Ayusin ang mga hiwa ng mansanas sa pie crust sa isang kawali
- 1.6. Bumalik sa hakbang 1.
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.
GO TO FULL VERSION