try-catch ב-Java: טיפול בחריגות בלי שהתוכנית תקרוס

לתפוס חריגה במקום לקרוס

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

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;          // זורק ArithmeticException
            System.out.println(result);   // לא מגיעים לכאן אף פעם
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program keeps running");
    }
}

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

משתנה ה-catch מחזיק את החריגה

ה-e ב-catch (ArithmeticException e) הוא אובייקט אמיתי. הוא נושא מידע על מה שהשתבש, והחלק השימושי ביותר הוא הודעה:

public class Main {
    public static void main(String[] args) {
        try {
            int n = Integer.parseInt("not a number");
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Bad input: " + e.getMessage());
        }
    }
}

e.getMessage() מחזירה תיאור קצר. בזמן דיבאג, e.printStackTrace() מדפיסה את כל ה-trace ומראה בדיוק מאיפה החריגה הגיעה. השתמשו בה כשהודעה לבדה לא מספיקה כדי למצוא את הסיבה.

תפסו את הטיפוס הספציפי, לא הכל

בלוק catch תופס רק חריגות שמתאימות לטיפוס שהוצהר בו (או למחלקת משנה שלו). טעות המתחילים הגדולה ביותר היא לתפוס Exception כדי ש"הבעיה תיעלם":

// אל תעשו את זה: זה מסתיר באגים אמיתיים
try {
    doWork();
} catch (Exception e) {
    // בולע NullPointerException, שגיאות הקלדה, שגיאות לוגיקה... הכל
}

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

טיפול בכמה טיפוסי חריגות

אפשר לערום כמה בלוקי catch. Java בודקת אותם מלמעלה למטה ומריצה את הראשון שמתאים, לכן סדרו אותם מהספציפי ביותר לכללי ביותר:

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "oops", null};

        for (String s : inputs) {
            try {
                int n = Integer.parseInt(s);
                System.out.println("Parsed: " + n);
            } catch (NumberFormatException e) {
                System.out.println("Not a number: " + s);
            } catch (NullPointerException e) {
                System.out.println("Got a null value");
            }
        }
    }
}

כששני טיפוסים מטופלים באותה דרך, השתמשו ב-multi-catch יחיד עם | במקום לשכפל את הבלוק:

public class Main {
    public static void main(String[] args) {
        try {
            Object[] words = {"a", "b"};
            System.out.println(words[5]);   // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Bad access: " + e.getClass().getSimpleName());
        }
    }
}

מלכודת: טיפוס כללי יותר חייב לבוא אחרי הספציפיים. אם שמים catch (Exception e) ראשון, הבלוקים הספציפיים שאחריו הופכים לבלתי ניתנים להשגה, והקומפיילר דוחה את הקוד.

finally תמיד רץ

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

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // זורק חריגה
            System.out.println("Working");  // מדולג
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // רץ בכל מקרה
        }
    }
}

"Closing resource" מודפס בין אם החריגה נזרקת ובין אם לא. עם זאת, הימנעו מ-return מתוך finally: הוא עלול להעלים חריגה בשקט או לדרוס ערך שהוחזר מבלוק ה-try.

try-with-resources סוגר דברים בשבילכם

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

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner מממש AutoCloseable, ולכן הוא נסגר אוטומטית
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

זה מחליף את הדפוס הישן של פתיחה ב-try וסגירה ב-finally, והוא פחות מועד לטעויות כי אי אפשר לשכוח לסגור. העדיפו אותו בכל פעם שאתם עובדים עם משאב שאפשר לסגור.

אל תשתמשו בחריגות לזרימת בקרה רגילה

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

// הימנעו: שימוש ב-catch כדי לבדוק אם מפתח חסר
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // טיפול במפתח החסר
}

// עדיף: לבדוק במפורש
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

שמרו את catch לדברים שבאמת לא בשליטתכם: קלט שגוי ממשתמש, קבצים חסרים, תקלות רשת.

הבא בתור: NullPointerException

החריגה הנפוצה ביותר שתתפסו (ותגרמו) ב-Java היא NullPointerException: היא מופיעה ברגע שקוראים למתודה על משהו שהתברר שהוא null. בעמוד הבא נצלול בדיוק למה שגורם לה, איך קוראים את ה-stack trace שלה, ואילו הרגלים מונעים ממנה לקרות מלכתחילה.