מפעילי קפיצה

Java תומך בשלושה אופרטורים קפיצה - break, continueו return. הם מעבירים את השליטה לחלק אחר של התוכנית שלך. בואו נשקול כל אחד מהמפעילים בפירוט.

שימוש במפעילbreak

האופרטור breakב-Java משמש בשלושה מקרים. ראשית, כפי שכבר ראית, זה מסיים את רצף ההצהרות בסניפי הצהרה switch. שנית, ניתן להשתמש בו כדי לצאת מלולאה. שלישית, זה יכול לשמש כצורה "מתורבתת" של אופרטור הקפיצה ללא תנאי goto. סעיף זה מסביר את שני המקרים האחרונים. השתמש breakכדי לצאת מלולאה על ידי שימוש ב- break, אתה יכול לאלץ את הלולאה להסתיים מיד, תוך עקיפת הביטוי המותנה וכל קוד שנותר בגוף הלולאה. כאשר נתקלים במשפט breakבתוך לולאה, השני מסתיים והשליטה בתוכנית מועברת להצהרה שאחריה. דוגמה פשוטה:

// Использование break для выхода из цикла.
public class BreakLoop {

  public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
      if (i == 4) {
        break; // завершить цикл, если i = 4
      }
      System.out.println("i: " + i);
    }
    System.out.println("Цикл завершен.");
  }
}

תוכנית זו מייצרת את הפלט הבא:

i: 0
i: 1
i: 2
i: 3
Цикл завершен.

למרות שהלולאה forמתוכננת כאן לבצע את ההצהרות שלה מ-0 עד 99 פעמים, האופרטור breakגורם לה להסתיים מוקדם כאשר i הוא 4. breakניתן להשתמש באופרטור עם כל אחת מהלולאות של Java, כולל לולאות אינסופיות בכוונה. לדוגמה, להלן התוכנית הקודמת מקודדת באמצעות לולאה while. הפלט של תוכנית זו זהה לקודמתה.

// Использование break для выхода из while-цикла.
public class BreakLoop2 {

  public static void main(String[] args) {
    int i = 0;
    while (i < 100) {
      if (i == 4) {
        break; // закончить цикл, если i = 4
      }
      System.out.println("i: " + i);
      i++;
    }
    System.out.println("Цикл завершен.");
  }
}

בשימוש בתוך קבוצה של לולאות מקוננות, ההצהרה breakתצא רק מהלולאה הפנימית ביותר. לדוגמה:

// Использование break во вложенных циклах.
public class BreakLoop3 {

  public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 10; j++) {
        if (j == 4) {
          break; // закончить цикл, если j = 4
        }
        System.out.print(j + " ");
      }
      System.out.println();
    }
    System.out.println("Цикл завершен.");
  }
}

תוכנית זו מייצרת את הפלט הבא:

Итерация 0: 0 1 2 3
Итерация 1: 0 1 2 3
Итерация 2: 0 1 2 3
Цикл завершен.

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

השתמש breakכטופסgoto

בנוסף לשימוש בהצהרות מתג ולולאות, breakניתן להשתמש בו גם לבד כצורה "מתורבתת" של ה- goto. Java לא מכילה את האופרטור gotoמכיוון שהיא מבצעת את הסניף בצורה שרירותית ולא מובנית. gotoבדרך כלל קשה להבין ולתחזק קוד שמשתמש ב- . זה גם עוקף כמה אופטימיזציות מהדר. עם זאת, ישנם מספר מקומות בתוכנית שבהם gotoזרימת הבקרה היא מבנה בעל ערך ולגיטימי. לדוגמה, gotoזה יכול להיות שימושי כאשר אתה פורץ מתוך קבוצה מקוננת עמוקה של לולאות. כדי לטפל במצבים כאלה, Java מגדירה צורה מורחבת של האופרטור break. באמצעותו, תוכל לצאת מגוש קוד אחד או יותר. בלוקים אלה אינם צריכים להיות חלק מלולאה או הצהרה switch. זה יכול להיות כל בלוק. לאחר מכן, תוכל לקבוע היכן בדיוק ימשיך הביצוע מכיוון שטופס זה breakעובד עם הסימן ומספק את היתרונות של goto, עוקף את הבעיות שלו. להצהרה breakמסומנת יש את הצורה הכללית הבאה: break label; הנה labelהשם של תווית המזהה גוש קוד כלשהו. כאשר טופס זה breakמבוצע, השליטה מועברת מבלוק הקוד הנקרא (שהתווית שלו מצוינת במשפט break) להצהרה שאחרי אותו בלוק. גוש קוד מסומן חייב לכלול משפט זה break, אך אין צורך שההכללה הזו תהיה ישירה (כלומר, breakניתן לכלול אותה לא ישירות בבלוק עם תווית משלו, אלא בבלוק המקנן בתוכו, אולי גם מסומן) . זה אומר שאתה יכול להשתמש באופרטור מסומן breakכדי לברוח מקבוצה של בלוקים מקוננים. אבל אתה לא יכול להשתמש breakבגוש קוד שאינו כולל break. כדי לתת שם לבלוק, הצב תווית בתחילת הבלוק (לפני הסד המתולתל הפותח). תווית היא כל מזהה Java חוקי ואחריו נקודתיים. לאחר תיוג בלוק, התווית שלו יכולה לשמש כארגומנט לאופרטור break. זה יגרום לביצוע המשך מסוף הבלוק המסומן. לדוגמה, התוכנית הבאה מכילה שלושה בלוקים מקוננים, כל אחד עם תווית משלו. המפעיל breakנע קדימה, מעבר לקצה הבלוק המסומן בתווית second, ומדלג על שני מפעילים println().

// Использование break How цивorзованной формы goto.
public class Break {

  public static void main(String[] args) {
    boolean t = true;
    first:
    {
      second:
      {
        third:
        {
          System.out.println("Перед оператором break.");
          if (t) {
            break second; // выход из блока second
          }
          System.out.println("Данный оператор никогда не выполнится");
        }
        System.out.println("Данный оператор никогда не выполнится ");
      }
      System.out.println("Данный оператор размещен после блока second.");
    }
  }
}

הפעלת תוכנית זו מייצרת את הפלט הבא:

Перед оператором break.
Данный оператор размещен после блока second.

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

// Использование break для выхода из вложенных циклов.
public class BreakLoop4 {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 100; j++) {

        if (j == 10) {
          break outer; // выйти из обоих циклов
        }
        System.out.print(j + " ");
      }
      System.out.println("Эта строка никогда не будет выведена");
    }
    System.out.println("Цикл завершен.");
  }
}

התוכנית מייצרת את הפלט הבא:

Итерация 0: 0 1 2 3 4 5 6 7 8 9 Цикл завершен.

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

// Эта программа содержит ошибку.
public class BreakErr {

  public static void main(String[] args) {
    one:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
    }
    for (int j = 0; j < 100; j++) {
      if (j == 10) {
        break one; //He верно!
      }
      System.out.print(j + " ");
    }
  }
}

מכיוון שלולאה המסומנת כאחת אינה כוללת משפט break, לא ניתן להעביר שליטה לבלוק זה.

שימוש במפעילcontinue

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

// Демонстрирует continue.
public class Continue {

  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      System.out.print(i + " ");
      if (i % 2 == 0) {
        continue;
      }
      System.out.println("");
    }
  }
}

הקוד הזה משתמש בפעולה %(מודולו) כדי לבדוק אם משהו iשווה. אם כן, הלולאה ממשיכה ללא הדפסת תו חדש. פלט תוכנית:

0 1
2 3
4 5
6 7
8 9

בדומה לאופרטור break, continueניתן להגדיר תווית המציינת איזו לולאה מקיפה להמשיך. תוכנית לדוגמה שמשתמשת continueבהדפסת לוח כפל משולש מ-0 עד 9.

// Использование continue с меткой.
public class ContinueLabel {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 10; i++) {
      for (int j = 0; j < 10; j++) {
        if (j > i) {
          System.out.println();
          continue outer;
        }
        System.out.print(" " + (i * j));
      }
    }
    System.out.println();
  }
}

ההצהרה continueבדוגמה זו מסיימת את הערכת הלולאה j, וממשיכה עם האיטרציה הבאה של הלולאה המונעת על ידי i. פלט מתוכנית זו:

0
 0 1
 0 2 4
 0 3 6 9
 0 4 8 12 16
 0 5 10 15 20 25
 0 6 12 18 24 30 36
 0 7 14 21 28 35 42 49
 0 8 16 24 32 40 48 56 64
 0 9 18 27 36 45 54 63 72 81

זה שימושי לעתים נדירות ביותר continue. אחת הסיבות לכך היא ש-Java מספקת קבוצה עשירה של הצהרות לולאה שמתאימות לרוב היישומים. עם זאת, עבור אותם מצבים מיוחדים שבהם יש צורך לסיים את האיטרציה מוקדם, ההצהרה continueמספקת דרך מובנית לביצוע משימה זו.

מַפעִילreturn

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

// Демонстрирует return.
public class Return {

  public static void main(String[] args) {
    boolean t = true;
    System.out.println("Перед оператором return.");
    if (t) {
      return; // возврат в вызывающую программу
    }
    System.out.println("Этот оператор никогда не выполнится.");
  }
}

זה returnחוזר למערכת Java בזמן ריצה, מכיוון שזו המערכת שקוראת ל- main(). פלט מתוכנית זו:

Перед оператором return.

ייתכן שתבחין שההצהרה הסופית println()לא מבוצעת. בזמן הביצוע, returnהשליטה מועברת חזרה לתוכנית הקוראים. הערה אחת אחרונה. בתוכנית הקודמת, ifיש צורך באופרטור (t). בלעדיו, מהדר ג'אווה יזרוק שגיאת "קוד בלתי ניתן להשגה" מכיוון שהוא ידע שהמשפט האחרון println()לעולם לא יבוצע. כדי למנוע שגיאה זו, נעשה שימוש באופרטור (t) if; הוא מרמה את המהדר למען ההדגמה הזו. קישור למקור המקורי: מפעילי מעבר