מבוא
התוכניות הראשונות שלנו היו רצף של הוראות שבוצעו בזו אחר זו. בלי מזלגות. זהו HelloWorld, שמוציא ביטוי ברכה וחישובים אריתמטיים לקונסולה. לאחר התוכניות הראשונות למדנו להסתעף, כלומר התוכנית ביצעה פעולות מסוימות בהתאם לתנאים. כך תוכל לקודד את המזגן להפעלה לחימום וקירור:if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort
heaterOn();
בואו ניקח את הצעד הבא. בחיי היומיום אנו מבצעים לעתים קרובות פעולות מונוטוניות שחוזרות על עצמן, למשל, קילוף תפוחים לעוגה. ניתן לתאר את התהליך המרתק הזה כך:
-
אם יש תפוחים באגן, בצע את השלבים 1.1 עד 1.4:
- 1.1. קח תפוח
- 1.2. מנקים וחותכים אותו לפרוסות
- 1.3. מניחים על בסיס פשטידת הבצק במחבת
- 1.4. נחזור לשלב 1.
- הבה נקשר את עצמנו למספר התפוחים, אבל אם יש לנו מעט מהם, חלק מהפקודות היו מבוצעות לשווא ללא "מטען" (ואולי, היינו חותכים את עצמנו תוך כדי קילוף תפוח שאינו קיים).
- אם יש יותר תפוחים מצוותי העיבוד שלנו, חלק מהמוצרים לא יעברו עיבוד.
- "קוד" כזה קשה לקריאה, מכיל הרבה חזרות וקשה לשינוי.
לולאות הן אופרטורים לביצוע פעולות מספר פעמים.
לולאת ה-Java 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)
}
זה נעשה באופן הבא (שלב אחר שלב):
- אנו מעריכים את התנאי הבוליאני שעוקב אחרי ה-while בסוגריים.
- אם התנאי הלוגי נכון, אזי האופרטורים בגוף הלולאה מבוצעים, לאחר ביצוע האופרטור האחרון בגוף הלולאה, עבור לשלב 1
- אם התנאי הלוגי הוא שקר, אז עבור למשפט הראשון מחוץ ללולאת while.
לולאה עם תנאי מוקדם
מכיוון שלפני ביצוע גוף הלולאה, אנו תמיד מחשבים מראש ביטוי לוגי (התנאי לכניסה ללולאה), סוג זה של 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
לולאה עם postcondition
סוג שני של מחזור:do {
// Loop body - periodically executed statement(s)
}while (Логическое выражение);
בוצע באופן הבא (שלבים):
- גוף הלולאה מבוצע (מיד אחרי מילת המפתח do).
- אנו מעריכים את התנאי הבוליאני שעוקב אחרי ה-while בסוגריים.
- אם התנאי הלוגי נכון, עבור לשלב 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
שימו לב לשינויים בקוד, השוו אותו לגרסת הלולאה עם תנאי מוקדם.
עובדות מעניינות על עבודה עם לולאות
פקודות שליטה בגוף הלולאה
ישנן שתי פקודות שמשפיעות על התקדמות הלולאה: break, שאת התכונות שלה נציג בפרק הבא, ו- continue – מפסיק את ביצוע הגוף של הלולאה הנוכחית ועובר לביטוי הלוגי של אופרטור 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