שאלת מבחן בתכנות מונחה עצמים - אוניברסיטת בר-אילן 2016 - חריגות

שאלה 3 (20 נקודות) סעיף א (10 מתוך 20 נקודות): מה יהיה פלט התחנוניות של התיקניות בתוכנה: ```java class E1 extends Exception {} class E2 extends E3 {} class E3 extends E1 {} class E4 extends E1 {} public class TryMe { static void f2() throws Exception { try { throw new E2(); } finally { System.out.println("f2-finally"); } } static void f1() throws Exception { try { f2(); } catch (E3 e) { System.out.println("f1-catch-E3"); throw new E4(); } catch (E4 e) { System.out.println("f1-catch-E4"); throw new E1(); } finally { System.out.println("f1-finally"); } } public static void main(String[] args) throws Exception { try { f1(); } catch (E1 e) { System.out.println(e.getClass().getSimpleName()); // this prints the actual class name of object e } catch (Exception e) { System.out.println("EXCEPTION"); } finally { System.out.println("main-finally"); } } } ``` סעיף ב (10 מתוך 20 נקודות): מה תהיה החתונוניות אם תשנו את 4 השורות הראשונות של התיקניות בתוכנה לתיקניות בתוכנה: ```java class E1 extends E2 {} class E2 extends Exception {} class E3 extends Exception {} class E4 extends Exception {} ```

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

פתרון: ### סעיף א **היררכיית החריגות:** - `E2` יורשת מ-`E3` - `E3` יורשת מ-`E1` - `E4` יורשת מ-`E1` - `E1` יורשת מ-`Exception` לכן, `E2` היא גם מופע של `E3` וגם של `E1`. `E4` היא גם מופע של `E1`. **מעקב אחר ריצת התוכנית:** 1. הביצוע מתחיל בפונקציה `main`, אשר קוראת ל-`f1()`. 2. `f1()` קוראת ל-`f2()`. 3. בתוך `f2()`, נזרקת **חריגה** חדשה מסוג `E2`. 4. לפני שהחריגה מתפשטת במעלה המחסנית, בלוק ה-**`finally`** של `f2()` מתבצע. - יודפס: `f2-finally` 5. החריגה מסוג `E2` מתפשטת אל `f1()`. המערכת מחפשת בלוק `catch` מתאים. 6. הבלוק הראשון הוא `catch (E3 e)`. מכיוון ש-`E2` היא מחלקת בת של `E3`, החריגה נתפסת כאן (עיקרון ה**פולימורפיזם**). - יודפס: `f1-catch-E3` 7. בתוך בלוק ה-`catch`, נזרקת **חריגה חדשה** מסוג `E4`. החריגה המקורית (`E2`) נמחקת. 8. לפני שהחריגה החדשה (`E4`) מתפשטת, בלוק ה-**`finally`** של `f1()` מתבצע. - יודפס: `f1-finally` 9. החריגה מסוג `E4` מתפשטת אל `main()`. המערכת מחפשת בלוק `catch` מתאים. 10. הבלוק הראשון הוא `catch (E1 e)`. מכיוון ש-`E4` היא מחלקת בת של `E1`, החריגה נתפסת כאן. 11. בתוך הבלוק, הפקודה `e.getClass().getSimpleName()` מדפיסה את שם המחלקה של האובייקט *האמיתי* שנתפס, שהוא `E4`. - יודפס: `E4` 12. לאחר סיום בלוק ה-`catch`, בלוק ה-**`finally`** של `main()` מתבצע. - יודפס: `main-finally` 13. התוכנית מסיימת. **הפלט הסופי לסעיף א:** f2-finally f1-catch-E3 f1-finally E4 main-finally ### סעיף ב **היררכיית החריגות החדשה:** - `E1` יורשת מ-`E2` - `E2` יורשת מ-`Exception` - `E3` יורשת מ-`Exception` - `E4` יורשת מ-`Exception` כעת, `E2`, `E3`, ו-`E4` הן מחלקות "אחיות" שאין ביניהן קשר ירושה, ו-`E1` היא תת-מחלקה של `E2`. **מעקב אחר ריצת התוכנית:** 1. השלבים 1-3 זהים: `main` קוראת ל-`f1`, שקוראת ל-`f2`, וב-`f2` נזרקת **חריגה** מסוג `E2`. 2. בלוק ה-**`finally`** של `f2()` מתבצע. - יודפס: `f2-finally` 3. החריגה מסוג `E2` מתפשטת אל `f1()`. המערכת מחפשת בלוק `catch` מתאים. 4. הבלוק הראשון הוא `catch (E3 e)`. `E2` אינה תת-מחלקה של `E3`, לכן החריגה לא נתפסת. 5. הבלוק השני הוא `catch (E4 e)`. `E2` אינה תת-מחלקה של `E4`, לכן החריגה לא נתפסת. 6. מכיוון שהחריגה לא נתפסה ב-`f1()`, היא עומדת להתפשט הלאה, אך לפני כן, בלוק ה-**`finally`** של `f1()` מתבצע. - יודפס: `f1-finally` 7. החריגה מסוג `E2` מתפשטת אל `main()`. 8. הבלוק הראשון הוא `catch (E1 e)`. `E2` אינה תת-מחלקה של `E1` (להיפך, `E1` היא תת-מחלקה של `E2`), לכן החריגה לא נתפסת. 9. הבלוק השני הוא `catch (Exception e)`. מכיוון שכל חריגה היא מופע של `Exception` (ובאופן מפורש `E2 extends Exception`), החריגה נתפסת כאן. - יודפס: `EXCEPTION` 10. לאחר סיום בלוק ה-`catch`, בלוק ה-**`finally`** של `main()` מתבצע. - יודפס: `main-finally` 11. התוכנית מסיימת. **הפלט הסופי לסעיף ב:** f2-finally f1-finally EXCEPTION main-finally