הצהרת הפסקה ב-Java

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

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

דוגמה זו תציג:

1
2
cycle was finished

המשמעות היא שכאשר מונה הלולאה iהופך שווה לפרמטר שעבר number, כלומר המספר 3, ביצוע הלולאה מסתיים מוקדם. אם לתוכנית יש כמה לולאות מקוננות, שבר את הפלטים רק מהלולאה הפנימית ביותר, לדוגמה:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

דוגמה זו מפיקה את הפלט:

012
012
012
012
012
cycles was finished

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

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

הפעלת דוגמה זו תפיק את הפלט:

4
after switch

הצהרת break העבירה את השליטה לקוד בעקבות הבלוק כולו switch. אם לא תציין breakבדוגמה switchזו:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

הפלט לא יהיה כצפוי:

4
4
after switch

זה קרה מכיוון שלאחר ביצוע הבלוק, case 2התוכנית המשיכה להפעיל את כל בלוקי המקרים הבאים , מה שנתן לנו את הפלט המתאים. לפעמים תכונה זו של המפעיל switch יכולה להועיל לנו, למשל:

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

תוכנית זו משווה מספר נתון למספר 5 ונותנת את הפלט הבא:

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

כאשר שיטה נקראת בפעם הראשונה, המפעיל switchמעביר את השליטה למפעיל case 2ולאחר מכן למפעיל breakב case 5. הקריאה השנייה דומה לראשונה, אך מתחילה ב-c case 7. השיחה השלישית לא מוצאת ערך מתאים בין כל המקרים, אז המפעיל מבוצע default. הדרך השלישית היא להשתמש באופרטור breakבמקום gotoבאופרטור C. לשם כך נשתמש בצורה מיוחדת של האופרטור breakשנקרא breakעם תווית. טופס זה נראה כמו break метка;Label - זה בדרך כלל כל שם מתאים ממרחב השמות של Java, לפני גוש קוד. יתרה מכך, לאחר החלת גוש קוד זה breakעם תווית, הקוד ימשיך להתבצע מהמקום שאחרי הבלוק עם התווית המתאימה, למשל:

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

דוגמה זו תפיק את הפלט הבא:

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

לאחר קריאת השיטה הראשונה, המפעיל breakמעביר את השליטה לסוף החסימה secondBlock, יציאה secondBlockו thirdBlock, תוך ביצוע מפעיל אחר println()בסוף firstBlock. לאחר השיחה השנייה, כל הקווים מוצגים על המסך. ניתן להשתמש בתוויות גם לציון מחזורים. יש לזכור שאתה יכול ללכת לתווית רק מתוך גוש הקוד שמצוין על ידי התווית; לדוגמה, קוד כזה לא יקמפל:

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

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