CodeGym /בלוג Java /Random-HE /הצהרת בעוד
John Squirrels
רָמָה
San Francisco

הצהרת בעוד

פורסם בקבוצה
התוכניות הראשונות שלנו היו רצף של הוראות שמתבצעות בזו אחר זו. בלי מזלגות. זה כולל את HelloWorld, שמציג ברכה. זה כולל חישובים אריתמטיים. לאחר התוכניות הראשונות שלנו, למדנו איך להסניף, כלומר איך לגרום לתוכנית לבצע פעולות שונות בהתאם לתנאים ספציפיים. הנה קוד לשליטה במערכת הסקה מרכזית ומיזוג אוויר:

if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();
קח את הצעד הבא. בחיי היומיום אנו מבצעים לעיתים קרובות פעולות חוזרות ונשנות, למשל, קילוף תפוחים לפשטידה. ניתן לתאר תהליך מרתק זה כך:
  1. אם יש תפוחים בקערה, אנו מבצעים את שלבים 1.1 עד 1.4:

    1. 1.1. תפוס תפוח
    2. 1.2. מקלפים וחותכים אותו לפרוסות
    3. 1.3. מסדרים את פרוסות התפוחים בתבנית הפאי בתבנית
    4. 1.4. חזור לשלב 1.
הצהרת ה-while - 2נניח שיש לך עשרה תפוחים, שתי ידיים וסכין אחת. בחיים האמיתיים, אתה מקלף ברצף את כל התריסר, לפי אותו אלגוריתם עבור כל תפוח. אבל איך אנחנו גורמים לתוכנית לעשות פעולה חוזרת על כל תפוח?
  • אנחנו קושרים את עצמנו למספר התפוחים, אבל אם אין לנו מספיק מהם, אז חלק מהפקודות יתבצעו ללא "עומס" (ואולי נחתוך את עצמנו תוך כדי ניסיון לקלף תפוח שלא קיים).
  • אם יש יותר תפוחים מאשר פקודות לקלף, אז חלק מהתפוחים יישארו לא קלופים.
  • קשה לקרוא קוד כזה. יש לו הרבה חזרות וקשה לשינוי.

לולאות הן אמירות המאפשרות לבצע פעולות שוב ושוב

לולאת ה-while של Java תעבוד טוב במקרה שלנו. מבנה זה מכניס פעולות מרובות למבנה תמציתי ומובן. באמצעות לולאת while , אלגוריתם חיתוך תפוחים לעוגה עשוי להיראות כך ב-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.");

תחביר פקודה

הגרסה הראשונה של הצהרת while היא כזו:

while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
להלן הסבר שלב אחר שלב של מה קורה כאשר קוד זה מבוצע:
  1. אנו מעריכים את הביטוי הבוליאני שנמצא בסוגריים לאחר מילת המפתח while .
  2. אם הביטוי הבוליאני מוערך כ-true, אז ההצהרות בגוף הלולאה מבוצעות. לאחר ביצוע ההצהרה האחרונה בגוף הלולאה, נעבור לשלב 1
  3. אם הביטוי הבוליאני מוערך ל-false, אז אנחנו קופצים להצהרה הראשונה אחרי לולאת while .

לולאה עם תנאי מוקדם

מכיוון שאנו תמיד מעריכים את הביטוי הבוליאני (התנאי לכניסה ללולאה) לפני שאנו מבצעים את גוף הלולאה, צורה זו של לולאת while נקראת לעתים קרובות לולאה עם תנאי מוקדם . בואו נבנה טבלה של עשרת החזקות הראשונות של מספר:

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++;
    }
}
פלט מסוף:

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

לולאה עם postcondition

הנה הגרסה השנייה של הלולאה הזו:

do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
להלן הסבר על מה שקורה כאשר הקוד הזה מופעל:
  1. גוף הלולאה מבוצע (מיד אחרי מילת המפתח do ).
  2. אנו מעריכים את הביטוי הבוליאני שנמצא בסוגריים לאחר מילת המפתח while .
  3. אם הביטוי הבוליאני מוערך כאמת, נעבור לשלב 1
  4. אם הביטוי הבוליאני מוערך ל-false, אז אנחנו קופצים להצהרה הראשונה אחרי לולאת while .
שני ההבדלים העיקריים מהלולאה הקודמת הם: 1) גוף הלולאה מבוצע לפחות פעם אחת ו-2) הביטוי הבולאני מוערך לאחר ביצוע גוף הלולאה. בהתאם, סוג זה של לולאת while נקראת לולאה עם postcondition . הפעם נציג טבלת חזקות של מספר שאינו עולה על 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
}
פלט מסוף:

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
שימו לב לשינויים בקוד. השווה זאת עם הלולאה עם תנאי מוקדם.

עובדות מעניינות על עבודה עם לולאות

הצהרות הסתעפות בתוך גוף הלולאה

ישנן שתי הצהרות המשפיעות על ביצוע בתוך לולאה: break (עליו נדון ביתר פירוט בפרק הבא) ו לְהַמשִׁיך.
  • continue — מדלג על ביצוע שאר גוף הלולאה באיטרציה הנוכחית וקופץ להערכת הביטוי הבוליאני של הצהרת while. אם הביטוי מוערך כ-true, אז הלולאה ממשיכה.
  • break - מפסיק מיד את הביצוע של האיטרציה הנוכחית ומעביר את השליטה להצהרה הראשונה אחרי הלולאה. לפיכך, הצהרה זו מסיימת את ביצוע הלולאה הנוכחית. נשקול זאת ביתר פירוט במאמר הבא.
זכור את דוגמה הפירות שלנו. אם איננו בטוחים באיכות התפוחים, נוכל לשנות את הקוד באמצעות הצהרת continue :

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());
}
הצהרת continue משמשת לעתים קרובות כאשר יש לבצע הצהרות בגוף הלולאה אם ​​מתקיים תנאי מסוים. לדוגמה, ייתכן שנרצה לבצע פעולות כאשר חיישן חומרה מופעל (אחרת, פשוט להמשיך את הלולאה בה אנו מבצעים קריאות חיישן) או שנרצה לחשב ביטוי רק באיטרציות מסוימות של לולאה. דוגמה למקרה האחרון ניתן לראות בשימוש שלנו בלולאת while לחישוב סכום הקוביות של מספרים טבעיים שהריבוע שלהם קטן ממספר המספרים. מְבוּלבָּל? בדוק את הקוד הבא:

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
}

לולאה אינסופית

הצהרות הסתעפות אלו משמשות לרוב בלולאות אינסופיות. אנו קוראים ללולאה אינסופית אם התנאי הבוליאני ליציאה מהלולאה לעולם לא מתקיים. בקוד, זה נראה בערך כך:

while (true) {
    // Loop body 
}
במקרה זה, הצהרת break עוזרת לנו לצאת מהלולאה. סוג זה של לולאה מתאים כאשר ממתינים לתנאים חיצוניים שנקבעו מחוץ לגוף הלולאה. למשל, במערכות הפעלה או משחקים (יציאה מהלולאה פירושה יציאה מהמשחק). או כשמשתמשים באלגוריתמים שמנסים, עם כל איטרציה של לולאה, לשפר תוצאה כלשהי, אבל מגבילים את מספר האיטרציות על סמך זמן שחלף או התרחשות של אירוע חיצוני (למשל דמקה, שחמט או תחזית מזג אוויר). זכור שבתנאים רגילים אינסוף לולאות אינן רצויות. כדי להדגים, נחזור להגדלת הערך:

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
    }
}
פלט מסוף:

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

לולאות מקוננות

ועכשיו אנחנו מגיעים לנושא האחרון שלנו על לולאות. זכור את עוגת התפוחים ההיא (אני מקווה שאתה לא רעב כרגע) ואת לולאת קילוף התפוחים שלנו:
  1. אם יש תפוחים בקערה, אנו מבצעים את שלבים 1.1 עד 1.4:

    1. 1.1. תפוס תפוח
    2. 1.2. מקלפים וחותכים אותו לפרוסות
    3. 1.3. מסדרים את פרוסות התפוחים בתבנית הפאי בתבנית
    4. 1.4. חזור לשלב 1.
נתאר את תהליך החיתוך ביתר פירוט:
  1. מספר פרוסות = 0
  2. כל עוד מספר הפרוסות הוא < 12, בצע את שלבים 2.1 עד 2.3

    1. 2.1. חותכים פרוסה נוספת מהתפוח
    2. 2.2. מספר פרוסות++
    3. 2.3. חזור לשלב 2
ונוסיף את זה לאלגוריתם הכנת העוגה שלנו:
  1. אם יש תפוחים בקערה, אנו מבצעים את שלבים 1.1 עד 1.6:

    1. 1.1. תפוס תפוח
    2. 1.2. לקלף את זה
    3. 1.3. מספר פרוסות = 0
    4. 1.4. כל עוד מספר הפרוסות הוא < 12, אז בצע את שלבים 1.4.1 עד 1.4.3
      1. 1.4.1. חותכים פרוסה נוספת מהתפוח
      2. 1.4.2. מספר פרוסות++
      3. 1.4.3. חזור לשלב 1.4
    5. 1.5. מסדרים את פרוסות התפוחים בתבנית הפאי בתבנית
    6. 1.6. חזור לשלב 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)"
}
פלט מסוף:
    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 ) הן אחד מאבני הבניין הבסיסיות של תוכנה. על ידי פתרון משימות ב- CodeGym, תלמד את כל סוגי הלולאות השונים, תבין את המורכבויות שלהן ותרכוש מיומנויות מעשיות בשימוש בהן.
הערות
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION