חריג זריקת Java

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

מה זה חריג ב-Java?

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

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

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

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

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

איך לזרוק חריג בג'אווה

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

throw new Exception("error…");

מילת המפתח throw ב-Java משמשת כדי לזרוק חריג משיטה או בלוק קוד כאשר מתרחשת שגיאה או מצב חריג שהתוכנית לא יכולה להתמודד עם בזמן הריצה . זרימת התוכנית מנותבת לגוש ה-catch הקרוב ביותר. בלוק זה יכול לנהל את החריגה.

דוגמה לשימוש במילת המפתח 'זרוק'

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

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

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

אין עוד שגיאות: תופסים דוגמה חריגה

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

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

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

• חסימת הניסיון . קוד שעלול להיות מסוכן מופעל כאן. זה קוד שיכול לזרוק חריג. אם מתרחש חריג בתוך בלוק try , ביצוע הקוד באותו בלוק מופסק, והשליטה מועברת לבלוק ה-catch.
• בלוק המלכוד . כאן מטופל החריג שנזרק. בבלוק ה- catch , אתה יכול לציין איזה חריג לתפוס ואיזה היגיון לבצע כאשר הוא נתפס.
החסימה לבסוף . זה מבוצע ללא קשר אם אירע חריג או לא. הבלוק הסופי משמש, למשל, לשחרור משאבים (כגון סגירת קובץ או שקע) שהוקצו בבלוק ניסיון. אתה יכול להשמיט את הבלוק הזה.

המבנה של try -catch-finally מאפשר שליטה מדויקת יותר על ביצוע התוכנית במקרה של מצבים חריגים ועוזר למנוע סיום בלתי צפוי של התוכנית במקרה של שגיאות. כעת, נחזור לדוגמא שלנו. אם מתרחשת חלוקה באפס במהלך שיטת החלוקה, תיזרק ArithmeticException , אשר נתפס על ידי בלוק ה-catch. בגוש ה- catch , אנו פשוט מדפיסים הודעת שגיאה לקונסולה. אם לא מתרחשת חריגה, התוכנית תמשיך בביצועה.

זורק מילת מפתח

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

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

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

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

בדוגמה זו, מתודה divide() נקראת עם ארגומנטים 10 ו-0, אשר יזרוק אי-legalArgumentException בגלל שחלוקה באפס היא בלתי אפשרית. החריג ייתפס על ידי בלוק try-catch , והודעת שגיאה תוצג. התוכנית תביא לערך של אפס מאחר והחריג מסיים את ביצוע שיטת divide() .