การแนะนำ
โปรแกรมแรกสุดของเราคือลำดับของคำสั่งที่ถูกดำเนินการทีละคำสั่ง ไม่มีส้อม นี่คือ HelloWorld ซึ่งส่งออกวลีทักทายและการคำนวณทางคณิตศาสตร์ไปยังคอนโซล หลังจากโปรแกรมแรก เราเรียนรู้ที่จะแยกสาขา นั่นคือ โปรแกรมดำเนินการบางอย่างขึ้นอยู่กับเงื่อนไข ต่อไปนี้คือวิธีที่คุณสามารถเขียนโค้ดให้เครื่องปรับอากาศเปิดเพื่อให้ระบบทำความร้อนและความเย็น:if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort
heaterOn();
เรามาทำตามขั้นตอนต่อไปกันดีกว่า ในชีวิตประจำวัน เรามักจะกระทำการกระทำที่ซ้ำซากจำเจ เช่น การปอกแอปเปิ้ลเป็นพาย กระบวนการอันน่าทึ่งนี้สามารถอธิบายได้ดังนี้:
-
หากมีแอปเปิ้ลอยู่ในกะละมัง ให้ทำตามขั้นตอนที่ 1.1 ถึง 1.4:
- 1.1. หยิบแอปเปิ้ล
- 1.2. ทำความสะอาดและหั่นเป็นชิ้น
- 1.3. วางบนฐานของพายขนมในกระทะ
- 1.4. กลับไปที่ขั้นตอนที่ 1 กัน

- ให้เราผูกมัดตัวเองเข้ากับจำนวนแอปเปิ้ล แต่ถ้าเรามีจำนวนแอปเปิ้ลน้อย คำสั่งบางคำสั่งก็จะถูกดำเนินการอย่างไร้ประโยชน์โดยไม่มี "น้ำหนักบรรทุก" (และบางที เราอาจจะตัดตัวเองในขณะที่ปอกแอปเปิ้ลที่ไม่มีอยู่จริง)
- หากมีแอปเปิลมากกว่าทีมงานแปรรูปของเรา ผลิตภัณฑ์บางส่วนอาจเข้าสู่สถานะไม่แปรรูป
- “โค้ด” ดังกล่าวอ่านยาก มีการซ้ำซ้อนจำนวนมาก และแก้ไขได้ยาก
ลูปเป็นตัวดำเนินการสำหรับการดำเนินการหลายครั้ง
Java while loop (vile loop) ทำงานได้ดีในกรณีของเรา การออกแบบนี้จัดการดำเนินการหลายอย่างให้เป็นโครงสร้างที่กระชับและเข้าใจได้ อัลกอริธึม while สำหรับการตัดแอปเปิ้ลสำหรับพายใน Java อาจมีลักษณะดังนี้:while(числоЯблокВТазике>0) {
яблоко = тазик.взятьОчередноеЯблоко();
положитьВПирог(яблоко.чистить().нарезать());
числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');
ไวยากรณ์คำสั่ง
วิธีแรกในการอธิบายคำสั่ง while มีดังนี้:while(Логическое выражение) {
// Loop body - periodically executed statement(s)
}
ทำได้ดังนี้ (ทีละขั้นตอน):
- เราประเมินเงื่อนไขบูลีนที่ตามหลังในขณะที่อยู่ในวงเล็บ
- หากเงื่อนไขลอจิคัลเป็นจริง ตัวดำเนินการในส่วนเนื้อหาของลูปจะถูกดำเนินการ หลังจากดำเนินการตัวดำเนินการสุดท้ายในส่วนเนื้อหาของลูป ให้ไปที่ขั้นตอนที่ 1
- หากเงื่อนไขลอจิคัลเป็นเท็จ เราจะไปที่คำสั่งแรกที่อยู่นอกลูป while
วนซ้ำโดยมีเงื่อนไขเบื้องต้น
เนื่องจากก่อนที่จะดำเนินการเนื้อความของลูป เราจะคำนวณนิพจน์เชิงตรรกะล่วงหน้าเสมอ (เงื่อนไขสำหรับการเข้าสู่ลูป) ในขณะที่ประเภทนี้มักเรียกว่าลูปที่มีเงื่อนไขเบื้องต้น มาสร้างตารางของจำนวนเต็มสิบตัวแรกที่กำลังบวกของตัวเลขกันดีกว่า:public static void main(String[] args) {
int number = 3; // Number to be raised to a power
int result = 1; // Result of exponentiation
int power = 1; // Initial exponent
while(power <= 10) { // loop entry condition
result = result * number;
System.out.println(number + "to the extent" + power + " = " + result);
power++;
}
}
ผลลัพธ์เอาต์พุตคอนโซล:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0
วนซ้ำกับเงื่อนไขภายหลัง
วงจรประเภทที่สอง:do {
// Loop body - periodically executed statement(s)
}while (Логическое выражение);
ดำเนินการดังต่อไปนี้ (ขั้นตอน):
- เนื้อความของลูปถูกดำเนินการ (ทันทีหลังจากคีย์เวิร์ด do)
- เราประเมินเงื่อนไขบูลีนที่ตามหลังในขณะที่อยู่ในวงเล็บ
- หากเงื่อนไขลอจิคัลเป็นจริง ให้ไปที่ขั้นตอนที่ 1
- หากเงื่อนไขลอจิคัลเป็นเท็จ เราจะไปที่คำสั่งแรกที่อยู่นอกลูป while
public static void main(String[] args) {
int number = 3;// Number to be raised to a power
int result = number;// Result of exponentiation
int power = 1;// Initial exponent
do {
System.out.println(number + "to the extent" + power + " = " + result);
power++;
result = result * number;
}while (result < 10000); // loop exit condition
ผลลัพธ์เอาต์พุตคอนโซล:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
Process finished with exit code 0
ให้ความสนใจกับการเปลี่ยนแปลงในโค้ด โดยเปรียบเทียบกับเวอร์ชันของลูปที่มีเงื่อนไขเบื้องต้น
ข้อเท็จจริงที่น่าสนใจเกี่ยวกับการทำงานกับลูป
คำสั่งควบคุมในส่วนเนื้อความของลูป
มีสองคำสั่งที่ส่งผลต่อความคืบหน้าของลูป: ตัวแบ่ง คุณสมบัติที่เราจะแสดงในบทถัดไป และ- ดำเนินการต่อ – หยุดการทำงานของเนื้อความของลูปปัจจุบันและย้ายไปยังนิพจน์เชิงตรรกะของตัวดำเนินการ while หากนิพจน์ที่คำนวณแล้วเป็นจริง การดำเนินการของลูปจะดำเนินต่อไป
- break – หยุดการทำงานของลูปปัจจุบันทันทีและข้ามไปยังคำสั่งแรกที่อยู่ด้านนอก ดังนั้นการดำเนินการของลูปปัจจุบันจึงถูกขัดจังหวะ เราจะดูรายละเอียดเพิ่มเติมในหัวข้อถัดไป
continue
:
while(числоЯблокВТазике>0) {
яблоко = тазик.взятьОчередноеЯблоко();
числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
if (яблоко.плохое()) { // method will return true for rotten, etc. apples
яблоко.выкинутьВМусор();
continue; // continue the loop, go to the condition number ofApplesIn the Basin>0
}
положитьВПирог(яблоко.чистить().нарезать());
}
โครงสร้าง
continue
มักจะใช้เมื่ออยู่ในเนื้อหาของลูปจำเป็นต้องดำเนินการคำสั่งเมื่อมีเงื่อนไขบางอย่างเกิดขึ้น เช่น เพื่อดำเนินการเมื่อเซ็นเซอร์ในอุปกรณ์ถูกกระตุ้น (ไม่เช่นนั้นเพียงอ่านวงจรการอ่านตัวบ่งชี้ต่อไป) หรือ เพื่อคำนวณนิพจน์เฉพาะบางขั้นตอนของวงจรเท่านั้น ตัวอย่างสำหรับกรณีสุดท้ายคือการคำนวณแบบวนรอบ while ของผลรวมของลูกบาศก์ของจำนวนธรรมชาติที่มีกำลังสองน้อยกว่าจำนวน:
public static void main(String[] args) {
int sum = 0; // total amount
int i = 0; // starting number of the row
int count = 20; // amount of numbers
while(i<=count) {
i++; // take the next number, i++ is equivalent to i=i+1
if (i*i<=count) // if the square of the number is less
continue; // number of numbers - do not count the sum
// move on to the next number in the loop
sum += i*i*i; // otherwise, we calculate the sum of cubes of numbers
} // sum += i*i*i - notation similar to sum = sum + i*i*i
System.out.println(sum);// print result
}
วงจรที่ไม่มีที่สิ้นสุด
คำสั่งควบคุมเหล่านี้มักใช้ในการวนซ้ำไม่สิ้นสุด มันถูกเรียกสิ่งนี้เนื่องจากเงื่อนไขการออกเชิงลอจิคัลไม่เป็นที่พอใจ ในโค้ดดูเหมือนว่า:while(true) {
// Loop body
}
break
ในกรณีนี้ การใช้คำสั่ง เพื่อจัดระเบียบทางออก จะมีประโยชน์ การวนซ้ำประเภทนี้เกิดขึ้นเมื่อรอเงื่อนไขภายนอกที่เกิดขึ้นนอกตรรกะของเนื้อความของลูป ตัวอย่างเช่น ในเกมที่จำลองโลกเสมือนจริงรอบๆ ฮีโร่ (ออกจากลูป = ออกจากเกม) ระบบปฏิบัติการ หรือเมื่อใช้อัลกอริธึม อาจปรับปรุงผลลัพธ์ด้วยการเรียกแต่ละครั้งในลูป แต่จำกัดไว้ตามเวลาหรือการเกิดเหตุการณ์ภายนอก (หมากฮอส หมากรุก หรือการพยากรณ์อากาศ) ควรจำไว้ว่าภายใต้สภาวะปกติ การวนซ้ำไม่รู้จบเป็นปัญหาหนึ่งของความไม่เสถียรของโปรแกรม เพื่อสาธิต ให้กลับไปสู่พลังของตัวเลข:
public static void main(String[] args) {
int number = 3; // Number to be raised to a power
int result = 1; // Result of exponentiation
int power = 1; // Initial exponent
while(true) {
result = result * number;
System.out.println(number + "to the extent" + power + " = " + result);
power++;
if (power>10)
break; // exit from the loop
}
}
ผลลัพธ์เอาต์พุตคอนโซล:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0
ลูปซ้อนกัน
เรามาถึงหัวข้อสุดท้ายเกี่ยวกับวัฏจักรของเรา ลองคิดถึงพายแอปเปิ้ล (หวังว่าคุณจะไม่หิวในขณะนี้) และ "ห่วง" ของเรา:-
หากมีแอปเปิ้ลอยู่ในกะละมัง ให้ทำตามขั้นตอนที่ 1.1 ถึง 1.4:
- 1.1. หยิบแอปเปิ้ล
- 1.2. ทำความสะอาดและหั่นเป็นชิ้น
- 1.3. วางบนฐานของพายขนมในกระทะ
- 1.4. กลับไปที่ขั้นตอนที่ 1 กัน
- จำนวนชิ้น = 0
-
แม้ว่าจำนวนชิ้นจะน้อยกว่า 12 ให้ทำตามขั้นตอนที่ 2.1 ถึง 2.3
- 2.1. ตัดแอปเปิ้ลอีกชิ้น
- 2.2. จำนวนชิ้น ++
- 2.3. กลับไปยังขั้นตอนที่ 2
-
หากมีแอปเปิ้ลอยู่ในกะละมัง ให้ทำตามขั้นตอนที่ 1.1 ถึง 1.6:
- 1.1. หยิบแอปเปิ้ล
- 1.2. ลอกออก
- 1.3. จำนวนชิ้น = 0
- 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
- 1.4.1. Отрезать очередную дольку от яблока
- 1.4.2. Кол-во долек ++ 1.4.3. Возвращаемся на шаг 1.4
- 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
- 1.6. Возвращаемся на шаг 1.

public static void main(String[] args) {
// Display the values of the second multiplier in the line
System.out.println(" 2 3 4 5 6 7 8 9");
int i = 2; // first multiplier, assign starting value
while(i<10) { // First loop, execute while the first multiplier is less than 10
System.out.print(i + " | ");// Display the first multiplier at the beginning of the string
int j = 2; // second multiplier, starting value
while (j<10) { // Second loop, execute while the second multiplier is less than 10
int mul=i*j; // Calculate the product of factors
if (mul<10) // If it contains one digit, print two spaces after it
System.out.print(mul + " ");
else // otherwise output the product and after it - one space
System.out.print(mul + " ");
j++; // Increase the second multiplier by one,
} // Go to the beginning of the second loop (while (j<10 ).... )
System.out.println(); // Move to the next line of output
i++; // Increase the first multiplier by one,
} // Go to the beginning of the first loop (while ( i<10 ) ....
}
Результат вывода на консоль:
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
Циклы (в частности, оператор while) – один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
GO TO FULL VERSION