היררכיית מחלקות החריגות

חלק מהיחידה תכנות מונחה עצמים במסלול ה-Java של Coddy. שיעור 59 מתוך 87.

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

בראש נמצאת Throwable, מחלקת האב של כל החריגות והשגיאות. יש לה שתי תת־מחלקות ישירות:

Throwable
├── Error          // בעיות חמורות (אל תתפסו אותן)
└── Exception      // בעיות שניתן להתאושש מהן
    └── RuntimeException  // חריגות שלא נבדקות

שגיאה מייצגת בעיות חמורות שיישומים לא אמורים לנסות לטפל בהן, כמו OutOfMemoryError או StackOverflowError. אלה מצביעות על בעיות יסודיות ב-JVM עצמו.

חריגה היא הענף שתעבוד איתו הכי הרבה. הוא מתחלק לשתי קטגוריות: חריגות בדוקות (מחלקות משנה ישירות של Exception) וחריגות לא בדוקות (מחלקות משנה של RuntimeException).

// מחלקות חריגה נפוצות
Exception
├── IOException           // בעיות בקבצים או ברשת
├── SQLException          // בעיות במסד הנתונים
└── RuntimeException
    ├── NullPointerException
    ├── ArrayIndexOutOfBoundsException
    └── IllegalArgumentException

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

try {
    // קוד כלשהו
} catch (Exception e) {
    // תופס את כל החריגות (בדרך כלל רחב מדי)
}

try {
    // קוד כלשהו
} catch (RuntimeException e) {
    // תופס רק חריגות בזמן ריצה ותתי־מחלקות שלהן
}

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

אתגר

קל

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

תארגנו את הקוד שלכם בשלושה קבצים:

ExceptionThrower.java: צרו מחלקה שיכולה להשליך סוגים שונים של חריגות בהתאם לקלט. המחלקה שלכם צריכה לכלול שלוש מתודות סטטיות:
triggerRuntime(String type) - בהתאם למחרוזת הסוג, השליכו חריגות זמן ריצה שונות:
- אם type הוא "null", השליכו NullPointerException עם ההודעה "Null value encountered"
- אם type הוא "index", השליכו ArrayIndexOutOfBoundsException עם ההודעה "Invalid index"
- אם type הוא "argument", השליכו IllegalArgumentException עם ההודעה "Bad argument"
triggerArithmetic() - השליכו ArithmeticException עם ההודעה "Division error"

triggerGeneric() - השליכו IllegalStateException עם ההודעה "Generic runtime error" (ההיררכיה שלה היא Exception > RuntimeException > IllegalStateException)
ExceptionAnalyzer.java: צרו מחלקה שתופסת חריגות ברמות שונות בהיררכיה ומזהה מה נתפס. כללו את המתודות הסטטיות הבאות:
analyzeSpecific(String type) - קראו ל-ExceptionThrower.triggerRuntime(type) בתוך בלוק try. השתמשו בבלוקי catch נפרדים עבור NullPointerException, ArrayIndexOutOfBoundsException ו-IllegalArgumentException. עבור כל אחד מהם, הדפיסו: Caught specific: [exception class simple name] ואחריו Message: [exception message]

analyzeWithParent() - קראו ל-ExceptionThrower.triggerArithmetic() בתוך בלוק try. תפסו אותה באמצעות RuntimeException (סוג האב). הדפיסו: Caught via parent: RuntimeException ואחריו Actual type: [exception class simple name]

analyzeWithGrandparent() - קראו ל-ExceptionThrower.triggerGeneric() בתוך בלוק try. תפסו אותה באמצעות Exception (רמה גבוהה יותר בהיררכיה). הדפיסו: Caught via grandparent: Exception ואחריו Actual type: [exception class simple name]
Main.java: חברו יחד את מנתח החריגות שלכם! תקבלו קלט אחד: מחרוזת מסוג חריגה (או "null", "index" או "argument").
תחילה, הדפיסו === Specific Catch === וקראו ל-analyzeSpecific עם הקלט שלכם.

לאחר מכן הדפיסו שורה ריקה, === Parent Catch ===, וקראו ל-analyzeWithParent.

לבסוף, הדפיסו שורה ריקה, === Grandparent Catch ===, וקראו ל-analyzeWithGrandparent.

תקבלו קלט אחד: סוג החריגה שיש להשליך ("null", "index" או "argument").

השתמשו ב-e.getClass().getSimpleName() כדי לקבל את שם המחלקה של החריגה וב-e.getMessage() כדי לקבל את ההודעה שלה. האתגר הזה מדגים שתפיסת סוג חריגה של מחלקת אב תופסת גם את כל המחלקות הצאצאיות שלה: זהו מושג מרכזי כשמחליטים עד כמה הטיפול בחריגות שלכם צריך להיות ספציפי!

נסו בעצמכם

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String type = scanner.nextLine();
        
        // TODO: הדפס את "=== Specific Catch ===" וקרא ל-ExceptionAnalyzer.analyzeSpecific(type)
        
        // TODO: הדפס שורה ריקה, לאחר מכן את "=== Parent Catch ===", ואז קרא ל-ExceptionAnalyzer.analyzeWithParent()
        
        // TODO: הדפס שורה ריקה, לאחר מכן את "=== Grandparent Catch ===", ואז קרא ל-ExceptionAnalyzer.analyzeWithGrandparent()
    }
}