מאמר בנושא חריגות/שגיאות בתכנות מונחה עצמים בשפת ג'אווה.

2. ‫בחריג‬ ‫טיפול‬‫ים‬–Exceptions Handling
,‫מסוימים‬ ‫ובמקרים‬ ‫סגורים‬ ‫למנגנונים‬ ‫המתכנת‬ ‫בידי‬ ‫אחרות‬ ‫בשפות‬ ‫היו‬ ‫אשר‬ ‫מכניות‬ ‫מטלות‬ ‫המון‬ ‫הפך‬ ‫ג'אווה‬ ‫בשפת‬ ‫תכנות‬
,‫המתכנת‬ ‫של‬ ‫המסוכנות‬ ‫מהידיים‬ ‫האחריות‬ ‫את‬ ‫לקחו‬ ‫אשר‬ ,"‫שחורות‬ ‫ל"קופסאות‬ ‫אף‬‫בתכנות‬ ‫להתעסק‬ ‫לו‬ ‫לאפשר‬ ‫במטרה‬
‫של‬ ‫הצלחה‬ ‫אי‬ ‫או‬ ‫הצלחה‬ ‫לתיאור‬ ‫קודים‬ ‫של‬ ‫רשימה‬ ‫תחזוקת‬ ‫או‬ ‫זיכרון‬ ‫של‬ ‫ופינוי‬ ‫הקצאה‬ ‫כגון‬ ‫תחזוקתיות‬ ‫בעבודות‬ ‫ולא‬
.‫בתכנית‬ ‫המתבצעות‬ ‫פעולות‬
‫צלחה‬ ‫או‬ ‫נכשלה‬ ‫המתודה‬ ‫פעולת‬ ‫האם‬ ‫לדעת‬ ‫ע"מ‬ ‫מתודות‬ ‫של‬ ‫חזרה‬ ‫בערכי‬ ‫להשתמש‬ ‫נהוג‬ ,‫שונות‬ ‫בשפות‬‫פעמים‬ ‫והרבה‬
‫מ‬‫שכל‬ ‫העובדה‬ ‫או‬ ‫לגיטימיים‬ ‫חזרה‬ ‫ערכי‬ ‫מגוון‬ ‫עקב‬ ‫התקלה‬ ‫לתיאור‬ ‫באופציות‬ ‫מחסור‬ ‫כגון‬ ‫בקשיים‬ ‫נתקלים‬ ‫אלו‬ ‫נגנונים‬
‫אחידות‬ ‫חוסר‬ ‫של‬ ‫בעיות‬ ‫גם‬ ‫כך‬ ‫ובשל‬ ‫הצלחה‬ ‫או‬ ‫כישלון‬ ‫שונה‬ ‫באופן‬ ‫להגדיר‬ ‫יכול‬ ‫מתכנת‬‫אחד‬ ‫חזרה‬ ‫ערך‬ ‫של‬ ‫משמעות‬ ‫וריבוי‬
‫שונים‬ ‫מתכנתים‬ ‫של‬ ‫לחזונם‬ ‫בהתאם‬.
‫ש‬ ‫קורה‬ ‫מעט‬ ‫לא‬‫תכנית‬‫מגיעה‬‫בו‬ ‫למצב‬‫את‬ ‫משתפת‬ ‫אשר‬ ‫אינטראקטיבית‬ ‫בתכנית‬ ‫מדובר‬ ‫באם‬ ‫לדוגמה‬ .‫תקלה‬ ‫קורה‬
‫או‬ ,‫ההזנה‬ ‫לחוקיות‬ ‫בנוגע‬ ‫מפורשות‬ ‫הוראות‬ ‫קיבל‬ ‫שזה‬ ‫ולמרות‬ ‫ערכים‬ ‫להזין‬ ‫האפשרות‬ ‫את‬ ‫לו‬ ‫שמקנה‬ ‫בכך‬ ‫המשתמש‬
.‫שגוי‬ ‫קלט‬ ‫ערך‬ ‫הזין‬ ‫המשתמש‬ ‫ואותו‬ ‫קרה‬ ,‫בטעות‬ ‫או‬ ‫הבנה‬ ‫מחוסר‬
‫ט‬ ,‫כה‬ ‫עד‬‫ו‬‫פל‬‫ו‬‫א‬ ‫בעיות‬‫לה‬‫למנוע‬ ‫ע"מ‬ ,‫היעד‬ ‫במקום‬ ‫השגויים‬ ‫הערכים‬ ‫של‬ ‫הצבתם‬ ‫מראש‬ ‫למנוע‬ ‫כדי‬ ‫פרטניות‬ ‫בדיקות‬ ‫ע"י‬
‫מראש‬‫ה‬ ‫את‬‫שגיאה‬,:‫לדוגמה‬‫של‬ ‫ביצוע‬‫בדיק‬‫הקלט‬ ‫ת‬‫למערך‬ ‫גישה‬ ‫לפני‬‫יודעים‬ ‫אנו‬ ‫שמראש‬ ‫כך‬‫ש‬‫לאינדקס‬ ‫נעשית‬ ‫הפניה‬
‫שהוגדר‬ ‫המערך‬ ‫מגבולות‬ ‫חורג‬ ‫שאינו‬ ‫חוקי‬‫ב‬ ‫מההגבלות‬ ‫חורג‬ ‫לא‬ ‫המוזן‬ ‫שהערך‬ ‫ו/או‬‫תכנית‬.
‫עלינו‬ ‫שיהיה‬ ‫להבין‬ ‫ניתן‬ ‫זו‬ ‫מדוגמה‬ ‫כבר‬‫את‬ ‫הכיוונים‬ ‫מכל‬ "‫"לסגור‬ ‫ע"מ‬ ‫תנאים‬ ‫המון‬ ‫ולייצר‬ ‫מקרים‬ ‫המון‬ ‫לכסות‬‫הפרצות‬ ‫כל‬
‫האפשריות‬‫אפשרית‬ ‫זו‬ ‫וטכניקה‬‫אמנם‬‫רבות‬ ‫קוד‬ ‫שורות‬ ‫בכתיבת‬ ‫מלווה‬ ‫אך‬ ,,‫מסוימים‬ ‫במקרים‬ ‫מסיבי‬ ‫קוד‬ ‫בשכפול‬‫ו‬‫כן‬ ‫כמו‬
.‫המתכנת‬ ‫מצד‬ ‫מיותרת‬ ‫בעבודה‬
‫מנת‬ ‫על‬‫ל‬‫אלו‬ ‫בעיות‬ ‫על‬ ‫התגבר‬‫בדבר‬ ‫שהוזכרו‬ ‫הבעיות‬ ‫ועל‬,‫החזרה‬ ‫ערכי‬‫משוכלל‬ ‫מנגנון‬ ‫הומצא‬‫יותר‬ ‫הרבה‬ ‫ויעיל‬‫לטיפול‬
‫ב‬‫חריג‬‫ים‬.
‫חריג‬ ‫של‬ ‫זריקה‬ ‫הממחיש‬ ‫קוד‬ ‫בקטע‬ ‫נתבונן‬‫ה‬‫פני‬ ‫של‬ ‫יוצא‬ ‫כפועל‬‫י‬:‫מערך‬ ‫מגבולות‬ ‫החורג‬ ‫לאינדקס‬ ‫ה‬
public class ExceptionExample1 {
public static void main(String[] args) {
int arrayOfInt[] = {0, 1, 2};
for(int index=1; index <= arrayOfInt.length; index++) {
System.out.println(arrayOfInt[index]);
}
}
}
‫ריצה‬ ‫זמן‬ ‫חריגת‬ ‫תניב‬ ‫זה‬ ‫קוד‬ ‫קטע‬ ‫של‬ ‫הרצה‬‫מהסוג‬ArrayIndexOutOfBoundsException:
Exception in thread "main" 1
2
java.lang.ArrayIndexOutOfBoundsException: 3
at ExceptionExample1.main(ExceptionExample1.java:9)
‫מנגנון‬ ‫אותו‬ ‫ע"י‬ ‫עבורנו‬ ‫סונתזה‬ ‫זו‬ ‫שגיאה‬ ‫הודעת‬ .‫זו‬ ‫השגיאה‬ ‫הודעת‬ ‫על‬ ‫לדווח‬ ‫בעצמנו‬ ‫דאגנו‬ ‫לא‬ ‫שאנו‬ ‫לב‬ ‫נשים‬Exceptions
.‫בשפה‬ "‫אין‬ ‫"בילד‬ ‫שקיים‬ ‫שהזכרנו‬
.‫הסיפור‬ ‫בכל‬ ‫המתכנת‬ ‫של‬ ‫תפקידו‬ ‫על‬ ‫לדבר‬ ‫נעבור‬ ,‫המערכת‬ ‫צד‬ ‫את‬ ‫משראינו‬ ‫כעת‬

3. ‫ובמקרים‬ ‫בקוד‬ ‫שנעשית‬ ‫פעולה‬ ‫מכל‬ ‫כתוצאה‬ ‫המערכת‬ ‫ע"י‬ ‫להיזרק‬ ‫שעלולות‬ ‫החריגות‬ ‫לסוגי‬ ‫מודע‬ ‫להיות‬ ‫המתכנת‬ ‫על‬
‫מהמערכת‬ ‫לצפות‬ ‫ניתן‬ ‫לא‬ ‫שהרי‬ ,‫ידיו‬ ‫על‬ ‫שנכתב‬ ‫מהמימוש‬ ‫הנובעות‬ ‫בתקלות‬ ‫לטפל‬ ‫שידעו‬ ‫משלו‬ ‫חריגות‬ ‫סוגי‬ ‫לייצר‬ ‫מסוימים‬
‫המתכנת‬ ‫ידי‬ ‫על‬ ‫שנכתבו‬ ‫מימושים‬ ‫עם‬ ‫להתמודד‬ ‫לדעת‬‫ו‬‫שאינ‬.‫בשפה‬ ‫מובנים‬ ‫ם‬
‫הזכרנו‬'‫מס‬ ‫כבר‬‫של‬ ‫היווצרותו‬ ‫עצם‬ ‫את‬ ‫חופשית‬ ‫בשפה‬ ‫לתאר‬ ‫נועד‬ ‫זה‬ ‫מינוח‬ .‫חריגה‬ ‫של‬ "‫"זריקה‬ ‫המושג‬ ‫את‬ ‫פעמים‬
‫אובייקט‬‫מה‬ ‫אחר‬ ‫או‬ ‫זה‬ ‫באופן‬ ‫שיורשת‬ ‫ממחלקה‬‫מחלקה‬Throwable‫תקלה‬ ‫או‬ ‫משגיאה‬ ‫כתוצאה‬ ,:
‫בתוך‬ ‫אוטומטית‬ ‫בצורה‬ ‫להיווצר‬ ‫יכול‬ ‫האובייקט‬ ‫אותו‬‫שהוא‬ ‫במתודה‬ ‫המתכנת‬ ‫ע"י‬ ‫ידני‬ ‫באופן‬ ‫או‬ ,‫כתובה‬ ‫מחלקה‬ ‫של‬ ‫מתודה‬
.‫בעצמו‬ ‫כתב‬
,‫חומרתי‬ ‫פיזי‬ ‫כשל‬ ‫להיות‬ ‫יכולות‬ ‫לשגיאה‬ ‫הסיבות‬.‫המתודה‬ ‫בהפעלת‬ ‫שגיאה‬ ‫או‬ ‫חיצוני‬ ‫ממקור‬ ‫קלט‬ ‫שגיאות‬
‫ובמ‬ ‫בתכנית‬ ‫להשתמש‬ ‫נוסף‬ ‫ניסיון‬ ‫למשתמש‬ ‫לאפשר‬ ‫ניתן‬ ,‫כן‬ ‫כמו‬ ,‫בתקלה‬ ‫ולטפל‬ ‫לנסות‬ ‫ניתן‬ ‫שגיאה‬ ‫של‬ ‫במקרה‬‫קיצון‬ ‫צב‬
.‫השגיאה‬ ‫על‬ ‫הודעה‬ ‫תוך‬ ‫מסודרת‬ ‫בצורה‬ ‫מהתכנית‬ ‫ולצאת‬ ‫הנתונים‬ ‫את‬ ‫לשמור‬ ‫פשוט‬ ‫ניתן‬
‫שצצה‬ ‫בבעיה‬ ‫לטפל‬ ‫ע"מ‬ ‫נוספות‬ ‫פעולות‬ ‫לבצע‬ ‫באפשרותנו‬ ‫שיש‬ ‫להסיק‬ ‫ניתן‬ ,‫קודם‬ ‫שהצגנו‬ ‫ומהדוגמה‬ ‫הכתוב‬ ‫מן‬‫ריצת‬ ‫בזמן‬
‫התכנית‬.‫כה‬ ‫עד‬ ‫ביצענו‬ ‫שלא‬
‫למצב‬ ‫תכנית‬ ‫מגיעה‬ ‫בהם‬ ‫רבים‬ ‫מקרים‬‫כגון‬ ‫תקלה‬,‫שהוצג‬ ‫זה‬.‫ריצה‬ ‫זמן‬ ‫חריגת‬ ‫של‬ ‫זריקה‬ ‫ידי‬ ‫על‬ ‫מטופלים‬‫למנוע‬ ‫מנת‬ ‫על‬
.‫שנזרקה‬ ‫החריגה‬ ‫את‬ "‫"לתפוס‬ ‫יש‬ ‫התכנית‬ ‫של‬ ‫קריסה‬
‫בצורת‬ ‫נכתב‬ ‫הריצה‬ ‫בזמן‬ ‫שנזרקות‬ ‫בחריגות‬ ‫לטפל‬ ‫ע"מ‬ ‫שנועד‬ ‫המנגנון‬‫בלוק‬Try-Catch.
‫בלוק‬try‫לכל‬ .‫חריגות‬ ‫לזרוק‬ ‫שעלול‬ ‫ככזה‬ ‫מגדירים‬ ‫אנו‬ ‫אותו‬ ‫לקטע‬ ‫כתוחם‬ ‫משמש‬‫בלוק‬try‫או‬ ‫אחד‬ ‫בלוק‬ ‫להצמיד‬ ‫יש‬ ‫שכזה‬
‫בלוק‬ ‫מסוג‬ ‫יותר‬catch.
‫בלוק‬ ‫כל‬ ‫להתאים‬ ‫ניתן‬catch.‫חריגות‬ ‫של‬ ‫שונים‬ ‫לסוגים‬ ‫שונה‬ ‫טיפול‬ ‫לאפשר‬ ‫כזה‬ ‫ובאופן‬ ‫חריגה‬ ‫של‬ ‫מסוים‬ ‫סוג‬ ‫שיתפוס‬ ‫כך‬

4. ‫בלוקי‬ ‫של‬ ‫שילוב‬ ‫תוך‬ ‫הנ"ל‬ ‫הדוגמה‬ ‫של‬ ‫שיפור‬ ‫נראה‬try‫ו‬-catch:‫מתאימים‬
public class ExceptionExample2 {
public static void main(String[] args) {
int arrayOfInt[] = {0, 1, 2};
for(int index=1; index <= arrayOfInt.length; index++) {
try {
System.out.println(arrayOfInt[index]);
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Index not in range!");
}
}
}
}
‫הודעת‬ ‫תתקבל‬ ‫לא‬ ‫כבר‬ ,‫זה‬ ‫קוד‬ ‫קטע‬ ‫בהרצת‬‫ה‬‫חריגה‬‫הנ"ל‬‫הבא‬ ‫הפלט‬ ‫אלא‬ ,‫התכנית‬ ‫של‬ ‫מסודר‬ ‫סיום‬ ‫תוך‬:
1
2
Index not in range!
‫הכללית‬ ‫התבנית‬‫"בלוק‬ ‫נקראת‬try-catch"‫כך‬ ‫ומוגדרת‬:
try {
//Code that might throw an exception...
}
catch(ExceptionOfType1 eot1) {
//In case of SomeException1 do...
}
catch(ExceptionOfType2 eot2) {
//In case of SomeException2 do...
}//...
‫ה‬ ‫בלוק‬-catch.‫מטפל‬ ‫הוא‬ ‫בו‬ ‫מהסוג‬ ‫ממחלקה‬ ‫שיורשות‬ ‫ממחלקה‬ ‫או‬ ‫מטפל‬ ‫הוא‬ ‫בו‬ ‫מהסוג‬ ‫לחריגה‬ "‫כניסה‬ ‫"נקודת‬ ‫מאפשר‬
‫הב‬‫הראשון‬ ‫לוק‬‫זה‬ ‫במקרה‬‫מ‬ ‫חריגה‬ ‫מקבל‬‫טיפו‬‫ס‬ExceptionOfType1‫בשם‬eot1‫מ‬ ‫חריגה‬ ‫מקבל‬ ‫השני‬ ‫והבלוק‬‫טיפוס‬
ExceptionOfType2‫בשם‬eot2.
‫ה‬ ‫בלוק‬ ‫ע"י‬ ‫תיתפס‬ ‫החריגה‬-catch‫בלוק‬ ‫קיים‬ ‫באם‬ ‫תלות‬ ‫מבלי‬ ,‫בה‬ ‫לטפל‬ ‫שיכול‬ ‫הראשון‬catch.‫בהמשך‬ ‫יותר‬ ‫מתאים‬
‫החריגה‬ ‫אותה‬ ‫אם‬‫בלוק‬ ‫שום‬ ‫ע"י‬ ‫נתפסה‬ ‫לא‬catch‫ב‬ ‫שימוש‬ ‫נעשה‬ ‫לא‬ ‫כאילו‬ ‫יהיה‬ ‫הטיפול‬ ‫המשך‬ ,-try-catch.
‫ל‬ ‫יהיה‬ ‫ניתן‬ ,‫נתפסה‬ ‫אכן‬ ‫והחריגה‬ ‫במקרה‬‫ש‬ ‫לבעיה‬ ‫הקשורים‬ ‫נתונים‬ ‫ממנה‬ ‫קרוא‬‫נוצרה‬ ‫בגינה‬,,‫בבעיה‬ ‫לטפל‬‫את‬ ‫לזרוק‬
‫החריגה‬‫הלאה‬.‫ועוד‬
:‫לב‬ ‫שימו‬‫של‬ ‫בלוקים‬try‫ו‬catch -,‫אחרים‬ ‫בלוקים‬ ‫כמו‬)‫לולאות‬ ‫(כגון‬.‫עצמו‬ ‫בפני‬ ‫הגדרה‬ ‫כתחום‬ ‫נחשבים‬‫שבמקרה‬ ‫כך‬
‫ובתוך‬‫בלוק‬‫ה‬try-,‫משתנה‬ ‫יוגדר‬‫יוכר‬ ‫לא‬ ‫הוא‬‫אל‬.‫לבלוק‬ ‫מחוץ‬
‫זו‬ ‫לבעיה‬ ‫פתרון‬:‫ה‬ ‫לבלוק‬ ‫הכניסה‬ ‫לפני‬try-‫ל‬ ,‫הגד‬‫י‬‫ר‬‫לבלוק‬ ‫מחוץ‬ ‫גם‬ ‫משמעות‬ ‫להם‬ ‫שיש‬ ‫משתנים‬
‫(אובייקטים‬ ‫כלשהו‬ ‫ריק‬ ‫התחלתי‬ ‫ערך‬ ‫להם‬ ‫ולתת‬‫יקבלו‬(null.

5. finally
‫ה‬ ‫בלוק‬-finally‫של‬ ‫הרצה‬ ‫המאפשר‬ ‫בלוק‬ ‫הוא‬‫שיתבצעו‬ ‫פעולות‬‫מקרה‬ ‫בכל‬‫אוסף‬ ‫ביצוע‬ ‫בסוף‬‫של‬ ‫המותנה‬ ‫הפעולות‬
‫ה‬ ‫בלוק‬-try-catch‫גם‬ ,‫תיתפס‬ ‫והיא‬ ‫חריגה‬ ‫תיזרק‬ ‫אם‬ ‫גם‬ ,‫כלומר‬ ,‫תיזרק‬ ‫לא‬ ‫אם‬ ‫וגם‬ ‫תיתפס‬ ‫לא‬ ‫והיא‬ ‫חריגה‬ ‫תיזרק‬ ‫אם‬
.‫בכלל‬ ‫חריגה‬
‫יופעל‬ ‫לא‬ ‫זה‬ ‫בלוק‬ ‫בהם‬ ‫קיצוניים‬ ‫מקרים‬ ‫שקיימים‬ ‫כמובן‬‫בבלוק‬ ‫הקוד‬ ‫קטע‬ ‫ביצוע‬ ‫טרם‬ ‫קרו‬ ‫והם‬ ‫בהנחה‬ ‫זאת‬ ,:
‫מתודת‬ ‫התהליכון‬ ‫באותו‬ ‫והופעלה‬ ‫בתהליכון‬ ‫רץ‬ ‫הבלוק‬stop().
‫המתודה‬ ‫הופעלה‬System.exit()‫פעו‬ ‫להפסקת‬ ‫גורמת‬ ‫אשר‬‫ה‬ ‫של‬ ‫לתו‬-JVM.
.‫עצמו‬ ‫הבלוק‬ ‫בתוך‬ ‫כהלכה‬ ‫טופלה‬ ‫ולא‬ ‫נתפסה‬ ‫שלא‬ ‫חריגה‬ ‫נזרקה‬
‫ה‬ ‫בלוק‬-finally‫להציבו‬ ‫יש‬ ,‫שומש‬ ‫הוא‬ ‫באם‬ ‫אך‬ ,‫בו‬ ‫שימוש‬ ‫חובת‬ ‫ואין‬ ‫רשות‬ ‫בלוק‬ ‫הוא‬‫רשימת‬ ‫סוף‬ ‫אחרי‬‫בלוקי‬‫ה‬-catch.
‫בו‬ ‫לשימוש‬ ‫דוגמה‬ ‫נראה‬:
public class ExceptionExample3 {
public static void main(String[] args) {
int arrayOfInt[] = {0, 1, 2};
for(int index=1; index <= arrayOfInt.length; index++) {
try {
System.out.println(arrayOfInt[index]);
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Index not in range!");
}
finally {
System.out.println("This will print anyway!");
}
}
}
}
‫נציין‬:‫קטע‬ ‫יתבצע‬ ,‫נתפסה‬ ‫והחריגה‬ ‫במידה‬ .‫החריגה‬ ‫נזרקה‬ ‫בה‬ ‫בשורה‬ ‫פעולתה‬ ‫את‬ ‫תפסיק‬ ‫התכנית‬ ,‫חריגה‬ ‫נזרקה‬ ‫באם‬
‫ה‬ ‫בלוק‬ ‫שבתוך‬ ‫הקוד‬-finally‫ה‬ ‫לבלוק‬ ‫תחזור‬ ‫ולא‬ ‫שאחריו‬ ‫הקוד‬ ‫משורת‬ ‫פעולתה‬ ‫את‬ ‫תמשיך‬ ‫והתכנית‬-try!
‫ה‬ ‫בלוק‬ ‫שבתוך‬ ‫הקוד‬ ‫קטע‬ ‫יתבצע‬ ,‫נתפסה‬ ‫לא‬ ‫והחריגה‬ ‫במידה‬-finally.‫פעולתה‬ ‫את‬ ‫תפסיק‬ ‫והתכנית‬
‫בפקודה‬ ‫שימוש‬ ‫נעשה‬ ‫בו‬ ‫מצב‬ ‫היא‬ ‫לציון‬ ‫מעניינת‬ ‫נקודה‬return‫בלוק‬ ‫של‬ ‫גוף‬ ‫בתוך‬catch.
‫של‬ ‫להפסקה‬ ‫תגרום‬ ‫זו‬ ‫פקודה‬‫בלוק‬ ‫יופעל‬ ‫זה‬ ‫במקרה‬ ‫גם‬ ,‫לב‬ ‫לשים‬ ‫יש‬ ‫אך‬ ,‫שהוחזר‬ ‫הערך‬ ‫עם‬ ‫וליציאה‬ ‫המתודה‬ ‫פעולת‬
‫ה‬-finally!‫מהמתודה‬ ‫היציאה‬ ‫לאחר‬ ‫תתבצע‬ ‫שפעולתו‬ ‫הוא‬ ‫שמעניין‬ ‫ומה‬‫בהם‬ ‫מקרים‬ ‫על‬ ‫לחשוב‬ ‫כמובן‬ ‫מתבקש‬ ‫(כאן‬
‫מטיפוס‬ ‫נניח‬ ‫מסוים‬ ‫ערך‬ ‫שמחזירה‬ ‫מתודה‬Integer‫או‬Boolean‫הזה‬ ‫הערך‬ ‫מהמתודה‬ ‫היציאה‬ ‫ולאחר‬‫משתנה‬‫בבלוק‬‫ה‬‫סיום‬)
‫ב‬ ‫שימוש‬ ‫ייעשה‬ ‫בהם‬ ‫במקרים‬ ‫גם‬-break, continue‫או‬throw‫בלוק‬ ‫ירוץ‬ ,‫ה‬-finally.‫הסיום‬ ‫טרם‬

6. ,‫כן‬ ‫אם‬‫ל‬ ‫ניתן‬‫כתוב‬‫כללית‬ ‫תבנית‬‫כך‬ ,‫במנגנון‬ ‫לשימוש‬ ‫יותר‬:
try {
//Code that might throw an exception...
}
catch(ExceptionOfType1 eot1) {
//In case of ExceptionOfType1 do...
}
catch(ExceptionOfType2 eot2) {
//In case of ExceptionOfType2 do...
}…
finally {
//Do this part anyway!
}
throw
‫בח‬ ‫עסקנו‬ ,‫כה‬ ‫עד‬‫מובנות‬ ‫שיטות‬ ‫ידי‬ ‫על‬ ‫שנזרקו‬ ‫ריגות‬‫בשפה‬..‫אחרים‬ ‫מפתחים‬ ‫ע"י‬ ‫שנזרקו‬ ‫חריגות‬ "‫"לתפוס‬ ‫למדנו‬ ,‫כלומר‬
‫ולה‬ ‫משלו‬ ‫חריגות‬ ‫ליצור‬ ‫המתכנת‬ ‫באפשרות‬ ‫יש‬ ,‫כאמור‬‫יעזר‬‫בהן‬‫בתוכנית‬‫שימוש‬ ‫תוך‬ ,‫החריגו‬ ‫במנגנון‬‫ת‬‫השפה‬ ‫של‬.
‫הפקודה‬ ‫בעזרת‬ ‫מתבצעת‬ ‫חריגה‬ ‫של‬ ‫זריקה‬throw‫ב‬‫א‬‫ו‬‫פן‬‫הבא‬:
throw new MyException();
‫ממשפט‬ ‫כחלק‬ ‫תבוצע‬ ‫היא‬ ‫ולרוב‬:‫הבא‬ ‫באופן‬ ‫לדוגמה‬ ‫תנאי‬
if (!myObject.exists()) {
throw new SQLException("Not Exist in DB!");
}
‫ה‬‫חריג‬‫ות‬‫ה‬ ‫לזרוק‬ ‫שניתן‬‫ן‬‫מ‬ ‫אובייקטים‬‫המובנית‬ ‫המחלקה‬ ‫את‬ ‫שמרחיבה‬ ‫מחלקה‬ ‫כל‬Exception‫ה‬ ,‫ה‬ ‫ספריות‬‫מובנות‬
‫בג‬‫רבים‬ ‫חריגות‬ ‫סוגי‬ ‫מכילות‬ ‫'אווה‬‫ב‬ ‫כבר‬ ‫נתקלנו‬ ,-NullPointerException, ArrayIndexOutOfBoundsException
‫ו‬,‫צויין‬ ‫שכבר‬ ‫כמו‬‫ליצו‬ ‫ניתן‬‫ר‬‫חדשים‬ ‫סוגים‬ ‫גם‬‫אישית‬ ‫ומותאמים‬.‫חריגות‬ ‫של‬
‫יכלול‬ ,‫לרוב‬‫שם‬‫ה‬‫מחלק‬‫ה‬‫המילה‬ ‫את‬ ‫בסופו‬Exception,‫לא‬ ‫זה‬‫חובה‬‫א‬ ,‫ך‬‫זה‬ ‫במנהג‬ ‫לדבוק‬ ‫רצוי‬‫הזיהוי‬ ‫וקלות‬ ‫הבהירות‬ ‫לשם‬
‫של‬‫ש‬ ‫מחלקות‬‫מ‬‫תארות‬‫חריגות‬.
‫ב‬ ‫לשימוש‬ ‫נוספות‬ ‫דוגמאות‬-throw:
throw new Exception();
throw new RunTimeException("Illegal Input");

7. ‫מתי‬?
‫שימוש‬ ,‫כללי‬ ‫באופן‬‫בחריגות‬‫למצבים‬ ‫שמור‬‫בהם‬‫התנהגות‬‫התוכנית‬‫אינה‬‫של‬ ‫היסוד‬ ‫הנחת‬ ‫שבו‬ ‫ברגע‬ ,‫כלומר‬ ,‫ברורה‬
.‫כשקרית‬ ‫מתבררת‬ ‫מסוים‬ ‫קוד‬ ‫קטע‬ ‫אמיתות‬
‫ה‬‫דוגמאות‬‫פנייה‬ :‫שראינו‬‫לאיבר‬‫לא‬‫חוקי‬‫במערך‬,‫או‬‫שמכיל‬ ‫במשתנה‬ ‫שימוש‬NULL,‫במנגנון‬ ‫לשימוש‬ ‫טובות‬ ‫דוגמאות‬ ‫אינן‬ ,
‫ועל‬ ‫המתכנת‬ ‫של‬ ‫בשליטתו‬ ‫שאינן‬ ‫מתקלות‬ ‫או‬ ‫לקויה‬ ‫קוד‬ ‫מכתיבת‬ ‫שנובעות‬ ‫שגיאות‬ ‫הן‬ ‫זה‬ ‫מסוג‬ ‫שגיאות‬ .‫ריצה‬ ‫שגיאות‬ ‫אלו‬
.‫המנגנון‬ ‫ברמת‬ ‫ולא‬ ‫הקוד‬ ‫ברמת‬ ‫להיות‬ ‫צריך‬ ‫בהן‬ ‫הטיפול‬ ,‫כן‬‫היות‬ ‫בלבד‬ ‫ההמחשה‬ ‫לשם‬ ‫נעשה‬ ‫המנגנון‬ ‫ברמת‬ ‫בהן‬ ‫הטיפול‬
.‫ורעיונית‬ ‫ויזואלית‬ ‫מבחינה‬ ‫בהן‬ ‫להתבונן‬ ‫שנוח‬ ‫דוגמאות‬ ‫ואלו‬
‫התכנית‬ ‫התנהגות‬ ‫האם‬ ‫עצמנו‬ ‫את‬ ‫נשאל‬ ,‫לא‬ ‫ומתי‬ ‫בחריגות‬ ‫בשימוש‬ ‫צורך‬ ‫יש‬ ‫למתי‬ ‫בנוגע‬ ‫האבחנה‬ ‫את‬ ‫לעשות‬ ‫מנת‬ ‫על‬
‫המת‬ ‫מקרים‬ ‫שני‬ ‫נציג‬ ?‫לא‬ ‫או‬ ‫מסוים‬ ‫קוד‬ ‫קטע‬ ‫עבור‬ ‫ברורה‬:‫לשאלה‬ ‫אחרת‬ ‫תשובה‬ ‫אחד‬ ‫כל‬ ,‫ברור‬ ‫באופן‬ ‫ארים‬
‫ממחלקה‬ ‫יורשת‬ ‫המחלקה‬ ‫אותה‬ ‫האם‬ ‫תשובה‬ ‫להחזיר‬ ‫ותפקידה‬ ‫שרירותית‬ ‫מחלקה‬ ‫איזושהי‬ ‫שמקבלת‬ ‫מתודה‬ ‫ונתונה‬ ‫נניח‬
‫אותה‬ ‫המחלקה‬ ‫אם‬ ‫גם‬ ‫בעיה‬ ‫תהיה‬ ‫לא‬ ,‫כלומר‬ ,‫שלילית‬ ‫או‬ ‫חיובית‬ ‫תשובה‬ ‫להחזיר‬ ‫יכולה‬ ‫זו‬ ‫מתודה‬ ."‫מ"רשימה‬ ‫נניח‬ ,‫אחרת‬
‫ת‬ ‫בוחנת‬ ‫היא‬!‫ברורה‬ ‫המתודה‬ ‫התנהגות‬ ‫בו‬ ‫למצב‬ ‫דוגמה‬ ‫זוהי‬ .‫ערך‬ ‫להחזיר‬ ‫תדע‬ ‫תמיד‬ ‫המתודה‬ ...‫לא‬ ‫אם‬ ‫וגם‬ ‫רשימה‬ ‫היה‬
.‫אורכה‬ ‫את‬ ‫ומחזירה‬ ‫רשימה‬ ‫מקבלת‬ ‫אשר‬ ,‫נוספת‬ ‫מתודה‬ ‫ומתונה‬ ‫נניח‬ ,‫זאת‬ ‫לעומת‬‫מה‬ ‫השאלה‬ ‫נשאלת‬ ‫המתודה‬ ‫בגוף‬
‫למתו‬ ‫שסופק‬ ‫שמה‬ ‫ההנחה‬ ‫על‬ ‫נשענת‬ ‫זו‬ ‫שאלה‬ ‫אך‬ ,‫למתודה‬ ‫שסופקה‬ ‫הרשימה‬ ‫אורך‬,‫כאן‬ ‫ולכן‬ ...‫רשימה‬ ‫אכן‬ ‫זו‬ ‫דה‬
.‫חריגה‬ ‫תיזרק‬ ‫שכאלו‬ ‫במקרים‬ ?‫רשימה‬ ‫סופקה‬ ‫לא‬ ‫אם‬ ‫מה‬ .‫ברורה‬ ‫אינה‬ ‫התכנית‬ ‫התנהגות‬
‫מהווה‬ ‫בחריגות‬ ‫שימוש‬‫יתרון‬,‫זה‬ ‫כלי‬ ‫ובעזרת‬ ‫היות‬ ‫מהותי‬‫של‬ ‫ביכולתו‬ ‫יש‬‫המ‬‫תכנת‬‫לקבוע‬‫בעצמו‬‫התנהגות‬ ‫אופי‬ ‫את‬
‫לבח‬ ‫יוכל‬ ‫המתכנת‬ .‫בעיה‬ ‫של‬ ‫מקרים‬ ‫אותם‬ ‫בכל‬ ‫שכתב‬ ‫התכנית‬‫תציג‬ ‫שהתכנית‬ ‫ור‬‫הודע‬‫ת‬‫שגיאה‬‫מתאימה‬,‫שהתכנית‬
,‫מהשגיאה‬ ‫תתעלם‬‫שהתכנית‬‫תקרוס‬‫אף‬ ‫ולרוב‬‫ניסיון‬ ‫יתבצע‬‫לפתור‬‫את‬‫הבעיה‬‫בזמן‬ ‫בו‬.
‫ה‬‫חיסרון‬‫בחריגות‬ ‫שימוש‬ ‫של‬.‫אחרים‬ ‫מובנים‬ ‫אוטומטיים‬ ‫במנגנונים‬ ‫שימוש‬ ‫מכל‬ ‫שנובע‬ ‫מהחיסרון‬ ‫שונה‬ ‫אינו‬
‫שף‬ ‫להעסיק‬ ‫מבקש‬ ‫אדם‬ ‫בו‬ ‫למצב‬ ‫זאת‬ ‫להקביל‬ ‫ניתן‬‫הייתה‬ ‫האיש‬ ‫של‬ ‫העיקרית‬ ‫מטרתו‬ .‫דרישה‬ ‫לפי‬ ‫ארוחות‬ ‫לו‬ ‫שיכין‬ ‫פרטי‬
‫מראש‬ ‫התראה‬ ‫נדרשה‬ ,‫כן‬ ‫כמו‬ ,‫מהרגיל‬ ‫גבוה‬ ‫היה‬ ‫כמובן‬ ‫המחיר‬ ,‫בעצמו‬ ‫האוכל‬ ‫את‬ ‫להכין‬ ‫צורך‬ ‫מבלי‬ ‫מוכנות‬ ‫ארוחות‬ ‫לקבל‬
‫ה"אובר‬ ‫זהו‬ .‫חשבונות‬ ‫בהנהלת‬ ‫וטיפול‬ ‫טלפון‬ ‫בשיחת‬ ‫שלוותה‬-.‫מוכנה‬ ‫שף‬ ‫בארוחת‬ ‫הרצון‬ ‫עקב‬ ‫שנוצר‬ "‫הד‬
‫ה‬‫"אובר‬-‫שנוצר‬ "‫הד‬‫החריגות‬ ‫במנגנון‬ ‫בשימוש‬‫עלות‬ ‫הוא‬‫זיכרון‬‫ו‬‫ב‬ ‫פגיעה‬‫יעילות‬‫זמן‬‫ה‬‫ריצה‬‫ה‬ ‫עקב‬‫ש‬ ‫עובדה‬‫חריגות‬‫בעצם‬ ‫הן‬
.‫אינסטנסיאציה‬ ‫תהליך‬ ‫של‬ ‫תוצר‬ ‫בעצם‬ ‫היא‬ ‫שנזרקת‬ ‫חריגה‬ ‫כל‬ ‫ולכן‬ ‫אובייקטים‬,‫כן‬ ‫כמו‬‫שימוש‬‫בחריגות‬‫מכריח‬‫אותנו‬‫להוסיף‬
‫בלוקים‬‫של‬try‫ושל‬catch,‫והתוצאה‬‫היא‬‫קוד‬‫ארוך‬‫יותר‬‫וקרי‬‫פחות‬ ‫א‬.
,‫למשל‬ ‫חביתה‬ ‫כגון‬ ‫פשוטה‬ ‫ארוחה‬ ‫לאכול‬ ‫האדם‬ ‫ירצה‬ ‫בהם‬ ‫שבמקרים‬ ‫כמסקנה‬ ‫לציין‬ ‫נוכל‬ ,‫השף‬ ‫ארוחות‬ ‫לדוגמת‬ ‫נחזור‬ ‫אם‬
‫ולטגן‬ ‫הביצה‬ ‫את‬ ‫לשבור‬ ,‫למטבח‬ ‫ללכת‬ ‫לו‬ ‫יהיה‬ ‫עדיף‬,‫בדיוק‬ ‫האופן‬ ‫ובאותו‬‫ה‬ ‫את‬ ‫נשמור‬‫ש‬‫י‬‫מ‬‫ו‬‫ש‬‫בחריגות‬‫ולא‬ ‫הצורך‬ ‫למקרה‬
‫זה‬ ‫במנגנון‬ ‫שימוש‬ ‫נעשה‬‫הצדקה‬ ‫ללא‬....‫פשוט‬ ‫תנאי‬ ‫משפט‬ ‫באמצעות‬ ‫הבעיה‬ ‫את‬ ‫לפתור‬ ‫פשוט‬ ‫ניתן‬ ‫מקרים‬ ‫בהרבה‬

8. :‫בחריגות‬ ‫לשימוש‬ ‫דוגמה‬ ‫נראה‬
import java.util.Scanner;
public class ExceptionExample4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int age = 0;
boolean isInteger = false;
do {
System.out.println("Enter patient age (without floating point): ");
String input = scanner.next();
try {
age = Integer.parseInt(input);
isInteger = true;
}
catch(NumberFormatException e) { //Exception thrown when the input isn't an int
isInteger = false;
}
} while(age < 0 || age > 120 || !isInteger);
System.out.println("Patient's age: "+age);
}
}
‫בדוגמה‬ExceptionExample4‫שימוש‬ ‫נעשה‬‫בחריגות‬‫ה‬ ‫שזורקת‬‫מתודה‬parseInt‫יזין‬ ‫שהמשתמש‬ ‫לכך‬ ‫לדאוג‬ ‫ע"מ‬‫את‬
‫(כ‬ ‫המטופל‬ ‫גיל‬‫שלם‬ ‫מספר‬)‫אחר‬ ‫משהו‬ ‫ולא‬.,‫כך‬ ‫לשם‬‫הקלט‬ ‫תקינות‬ ‫לגבי‬ ,‫כן‬ ‫וכמו‬ )‫(טווח‬ ‫הקלט‬ ‫אמיתות‬ ‫לגבי‬ ‫בדיקות‬ ‫נעשות‬
(‫פורמט‬.)

9. throws
Checked exceptions
‫מתודה‬ ‫בהם‬ ‫מצבים‬ ‫קיימים‬‫בתוך‬ ‫נתפסת‬ ‫שלא‬ ‫חריגה‬ ‫זורקת‬ ‫שכתבנו‬‫הגדרתה‬ ‫תחום‬.‫במ‬,‫אלו‬ ‫צבים‬‫להבין‬ ‫עלינו‬ ‫יש‬
‫יותר‬ ‫גבוה‬ ‫במקום‬ ‫לטיפול‬ ,‫המתודה‬ ‫לגבולות‬ ‫מחוץ‬ ‫אל‬ ‫נזרקת‬ ‫שהחריגה‬‫או‬ ,‫הופעלה‬ ‫האמורה‬ ‫המתודה‬ ‫שממנה‬ ‫במתודה‬ ,
‫אחרת‬ ‫במתודה‬.‫מבחוץ‬ ‫ולטפל‬ ‫לתפוס‬ ‫שמחכה‬ ‫מי‬ ‫שיש‬ ‫בתקווה‬‫ו‬ ‫במידה‬‫אחד‬ ‫באף‬ ‫נתפסה‬ ‫לא‬ ‫החריגה‬‫ה‬ ‫אז‬ ,‫מהשלבים‬-
default handler‫של‬Java‫השגיאה‬ ‫הודעת‬ ‫עם‬ ‫מסתיימת‬ ‫פשוט‬ ‫התכנית‬ ‫בהם‬ ‫המקרים‬ ‫(אלו‬ ‫בה‬ ‫יטפל‬–.)"‫"קורסת‬
,‫מהמתודה‬ ‫הלאה‬ ‫נזרקת‬ ‫החריגה‬ ‫בהם‬ ‫מצבים‬ ‫באותם‬‫ב‬ ‫במפורש‬ ‫זאת‬ ‫לציין‬ ‫חייבים‬‫באמצעות‬ ‫המתודה‬ ‫של‬ ‫ההצהרה‬ ‫שורת‬
‫השמורה‬ ‫המילה‬throws.
‫המתודה‬ ‫את‬ ‫לדוגמה‬ ‫נציג‬methodName‫אשר‬‫מטיפוס‬ ‫חריגה‬ ‫זורקת‬SomeException.‫ה‬‫המתודה‬ ‫צהרת‬‫כך‬ ‫תיראה‬:
private void methodName() throws SomeException { }
‫דומה‬ ‫באופן‬‫מ‬ ‫חריגות‬ ‫לזרוק‬ ‫מתודה‬ ‫יכולה‬ ,:‫אחד‬ ‫מטיפוס‬ ‫יותר‬
private void methodName() throws IOException, SQLException { }
‫הוספת‬ ‫של‬ ‫המשמעות‬‫לה‬ ‫זו‬ ‫הצהרה‬‫כרז‬,‫מתודה‬ ‫ת‬‫ש‬ ‫היא‬‫כל‬ ,‫הוספה‬ ‫שהיא‬ ‫מרגע‬‫ש‬ ‫מי‬‫במתודה‬ ‫ישתמש‬‫לתפיסה‬ ‫לדאוג‬ ‫חייב‬
‫אות‬ ‫החריגות‬ ‫של‬‫ן‬‫זורקת‬ ‫היא‬‫בלוק‬ ‫באמצעות‬ ‫או‬ ,try-catch‫או‬‫הכרזת‬ ‫של‬ ‫הוספה‬ ‫באמצעות‬throws‫ה‬ ‫באותה‬‫מתודה‬
" ‫היא‬ ‫כך‬ ‫של‬ ‫שהמשמעות‬‫זריקה‬"‫הלאה‬ ‫חריגה‬ ‫אותה‬ ‫של‬.
Unchecked exceptions
‫יוצא‬‫ות‬‫מן‬‫הכלל‬‫הן‬‫חריגות‬‫מהטיפוס‬Error‫ומהטיפוס‬RunTimeException‫וכל‬‫היורשים‬‫מה‬‫אשר‬ ,‫ן‬‫אינ‬‫ם‬‫דורש‬‫ים‬‫הכרזה‬
‫השמורה‬ ‫המילה‬ ‫באמצעות‬throws.
‫חריגות‬‫מטיפוס‬Error‫הן‬‫חריגות‬‫שנזרקות‬‫ב‬ ‫לשיבוש‬ ‫שגרמה‬ ‫חיצונית‬ ‫טכנית‬ ‫תקלה‬ ‫של‬ ‫קיומה‬ ‫בעת‬‫פעילות‬‫התוכנית‬‫לעתים‬ ,
‫ב‬ ‫בעיה‬-JVM‫זה‬ ‫מסוג‬ ‫תקלות‬ ‫על‬ ‫להצהיר‬ ‫צורך‬ ‫אין‬ ‫ולכן‬ ‫בהם‬ ‫לשלוט‬ ‫יכולים‬ ‫שאנו‬ ‫דברים‬ ‫לא‬ ‫ולרוב‬ '‫וכד‬–‫שלנו‬ ‫בידיים‬ ‫לא‬ ‫זה‬.
‫חריגות‬‫מטיפוס‬RunTimeError‫פשוטות‬ ‫ובמילים‬ ‫התכנית‬ ‫של‬ ‫בלוגיקה‬ ‫מבעיה‬ ‫לרוב‬ ‫נובעות‬–‫חובה‬ ‫אין‬ ,‫ולכן‬ ‫לקוי‬ ‫מתכנות‬
‫הצהרה‬ ‫על‬‫ע‬‫שהמתכ‬ ‫היא‬ ‫ההנחה‬ .‫זה‬ ‫מסוג‬ ‫חריגות‬ ‫בור‬‫שעלולות‬ ‫מתודות‬ :‫לדוגמה‬ .‫כראוי‬ ‫לתכנת‬ ‫ידאג‬ ‫נת‬‫לזרוק‬
NullPointerException‫קובץ‬ ‫מהרשת‬ ‫שמקבלת‬ ‫מתודה‬ ‫או‬ ,XML...‫מתאים‬ ‫לא‬ ‫כבר‬ ‫ולכן‬ ‫השתנה‬ ‫הפורמט‬ ‫אך‬ ,
‫ניתן‬‫לכתוב‬‫חריגות‬‫שמרחיבות‬‫את‬‫המחלקה‬RunTimeException‫ובכך‬‫להימנע‬‫מהצורך‬‫להכריז‬‫על‬‫חריגה‬‫מאותו‬‫טיפוס‬.
,‫כן‬ ‫אם‬ ‫מדוע‬‫את‬ '‫וכד‬ ‫תנאי‬ ‫משפטי‬ ‫באמצעות‬ ‫לבדוק‬ ‫היא‬ ‫האלטרנטיבה‬ ,‫ובכן‬ ?‫זה‬ ‫מסוג‬ ‫בחריגות‬ ‫זאת‬ ‫בכל‬ ‫להשתמש‬ ‫שנרצה‬
, ‫פשוט‬ ,‫יעיל‬ ‫יותר‬ ‫מה‬ ‫שיקול‬ ‫לעשות‬ ‫יש‬ ‫כזה‬ ‫במצב‬ ,‫ובכן‬ ,‫בהם‬ ‫להשתמש‬ ‫מכן‬ ‫לאחר‬ ‫ורק‬ ‫בעיה‬ ‫להוות‬ ‫שעלולים‬ ‫האלמנטים‬
.‫לביצוע‬ ‫וקל‬ ‫קריא‬
javadoc
‫תיעוד‬javadoc‫מתודה‬ ‫של‬‫חריגו‬ ‫שזורקת‬‫ת‬‫התגית‬ ‫את‬ ‫שיכיל‬ ‫רצוי‬ ,@throws‫י‬ ‫ובכך‬‫על‬ ‫דווח‬‫ה‬‫ש‬ ‫חריגה‬‫המתודה‬ ‫זורקת‬‫ו‬‫על‬
‫הקודמת‬ ‫לדוגמה‬ ‫נחזור‬ ‫אם‬ .)‫חריגה‬ ‫לכל‬ ‫(אלמנט‬ ‫לכך‬ ‫הסיבה‬‫ה‬ ‫הערת‬ ,-javadoc‫כדלהלן‬ ‫תיראה‬ ‫המתאימה‬:
/**
* @throws IOException if the file could not be read
* @throws SQLException for any database related problem
*/
private void methodName() throws IOException, SQLException { }

10. ‫היררכיה‬‫של‬‫חריגות‬
‫ה‬ ‫בתרשים‬ ‫שראינו‬ ‫כפי‬-UML‫המחלקות‬ ‫היררכיית‬ ‫את‬ ‫המתאר‬,‫חריגות‬ ‫שמתארות‬‫כל‬‫החריגות‬‫הרגילות‬‫יורשות‬‫מ‬‫המחלקה‬
Exception‫או‬‫מ‬‫מחלקות‬‫שיורשות‬‫מ‬‫המחלקה‬Exception.
‫שימוש‬‫בירושה‬‫ההורשה‬ ‫סולם‬ ‫של‬ ‫והיכרות‬ ‫הבנה‬ ,‫המתארות‬ ‫המחלקות‬ ‫של‬‫חריגות‬‫מאפשר‬‫לנו‬‫גמישות‬‫רבה‬‫מאתנו‬ ‫וחוסך‬
:‫אבסטרקטי‬ ‫פחות‬ ‫קצת‬ ‫ובאופן‬ ‫שלנו‬ ‫ההצהרות‬ ‫את‬ ‫אבסולוטי‬ ‫באופן‬ ‫לממש‬ ‫הצורך‬ ‫את‬
‫על‬ ‫ההצהרה‬ ‫בראש‬ ‫להכריז‬ ‫ניתן‬‫מתודה‬‫כי‬ ,‫היא‬‫זורקת‬‫חריגה‬‫מ‬‫מסוים‬ ‫טיפוס‬,‫ובפועל‬‫של‬ ‫זריקה‬ ‫לבצע‬ ,‫המתודה‬ ‫בגוף‬
‫חריגה‬‫מטיפוס‬‫אחר‬,‫שיורש‬‫מ‬‫הטיפוס‬‫עליו‬‫ה‬‫ו‬‫כרז‬‫המתודה‬ ‫בהצהרת‬.
,‫כן‬ ‫כמו‬‫בתוך‬‫בלוק‬try-catch,‫בלוק‬catch‫מ‬ ‫חריגות‬ ‫לתפוס‬ ‫שמיועד‬‫טיפוס‬‫מסוים‬,‫לת‬ ‫יכול‬‫פ‬‫ו‬‫ס‬‫גם‬‫חריגות‬‫מטיפוסים‬
‫שיורש‬‫ים‬.‫מסוים‬ ‫טיפוס‬ ‫מאותו‬
‫טובה‬ ‫בצורה‬ ‫הנושא‬ ‫את‬ ‫להבין‬ ‫מנת‬ ‫על‬‫הבאה‬ ‫בדוגמה‬ ‫נתבונן‬ ,‫יותר‬-‫נניח‬‫שכתבנו‬‫מחשב‬ ‫משחק‬ ‫המהווה‬ ‫תכנית‬,‫ובמהלך‬
‫הפרויקט‬‫השתמשנו‬‫ב‬:‫הבאים‬ ‫החריגות‬ ‫סוגי‬
public class GameServerException extends Exception {}
public class GameProtocolException extends GameServerException {}
public class PlayerException extends GameServerException {}
‫שקיימת‬ ‫נציין‬ ,‫כן‬ ‫כמו‬:‫המתודה‬
public void doSomething() throws GameServerException {
}
‫מטיפוס‬ ‫חריגות‬ ‫לזרוק‬ ‫יכולה‬ ‫זו‬ ‫מתודה‬ ‫כי‬ ‫ומוצהר‬ ‫היות‬GameServerException,‫באפשרותה‬ ‫יש‬‫חריגות‬ ‫לזרוק‬ ‫גם‬
‫מטיפוס‬:‫הירושה‬ ‫בסולם‬ ‫ממנה‬ ‫נמוך‬ ‫שנמצאת‬ ‫מחלקה‬GameProtocolException,PlayerException.
‫ל‬ ,‫זאת‬ ‫לעומת‬‫בלוק‬‫ה‬-try‫קריאה‬ ‫תהיה‬ ‫שבתוכו‬‫למתודה‬,‫בלוק‬ ‫להצמיד‬ ‫חייבים‬ ‫נהיה‬catch‫מסוגל‬ ‫אשר‬‫לתפוס‬‫חריגות‬
‫מהטיפוס‬GameServerException‫או‬‫מטיפוס‬‫הירושה‬ ‫בסולם‬ ‫ממנה‬ ‫גבוה‬ ‫שנמצאת‬ ‫מחלקה‬‫ו‬‫זה‬ ‫במקרה‬‫המחלקה‬
Exception(‫מטיפוס‬ ‫חריגות‬ ‫גם‬ ‫הבלוק‬ ‫בתוך‬ ‫לתפוס‬ ‫ניתן‬ ,‫הצורך‬ ‫במידת‬ProtocolException‫או‬ClientException.)
‫חריגות‬ ‫זריקת‬ ‫על‬ ‫שמצהירות‬ ‫מתודות‬ ‫של‬ ‫דריסה‬
‫מתודה‬ ‫של‬ ‫דריסה‬ ‫ונבצע‬ ‫במקרה‬‫כ‬,‫זו‬‫לזרוק‬ ‫תוכל‬ ‫הדורסת‬ ‫שהמתודה‬ ‫החריגות‬ ‫יהיו‬ ‫גם‬ ‫אלו‬.
‫ה‬‫מתודה‬‫ה‬‫לא‬ ‫דורסת‬‫דרסה‬ ‫היא‬ ‫אותה‬ ,‫המקורית‬ ‫שהמתודה‬ ‫החריגות‬ ‫את‬ ‫לזרוק‬ ‫חייבת‬,.‫זרקה‬
‫שזרקה‬ ‫חריגות‬ ‫של‬ ‫הטיפוסים‬ ‫מאותם‬ ‫להיות‬ ‫יכולות‬ ‫אלו‬ ‫חריגות‬ ,‫הדורסת‬ ‫במתודה‬ ‫חריגות‬ ‫לזרוק‬ ‫מתבקש‬ ‫ואכן‬ ‫במקרה‬
.‫המקורית‬ ‫המתודה‬ ‫שזרקה‬ ‫טיפוסים‬ ‫מאותם‬ ‫שיורשים‬ ‫מטיפוסים‬ ‫או‬ ,‫המקורית‬ ‫המתודה‬
‫באופ‬ ‫יכולה‬ ‫דורסת‬ ‫מתודה‬‫יותר‬ ‫לזרוק‬ ‫יכולה‬ ‫איננה‬ ‫היא‬ ‫אך‬ ,‫דרסה‬ ‫היא‬ ‫אותה‬ ‫מהמתודה‬ ‫חריגות‬ ‫פחות‬ ‫לזרוק‬ ‫לגיטימי‬ ‫ן‬
.‫ממנה‬
‫המתודה‬ ‫את‬ ‫נדרוס‬ ‫אם‬ ,‫שלנו‬ ‫בדוגמה‬doSomething():‫הבאות‬ ‫החריגות‬ ‫את‬ ‫לזרוק‬ ‫תוכל‬ ‫הדורסת‬ ‫המתודה‬ ,
GameServerException,)‫זרקה‬ ‫המקורית‬ ‫שהמתודה‬ ‫החריגה‬ ‫וזו‬ ‫(היות‬GameProtocolException‫ו‬-
PlayerException‫ואלו‬ ‫(היות‬‫חריגות‬‫שיורש‬.)‫זרקה‬ ‫המקורית‬ ‫שהמתודה‬ ‫מהחריגה‬ ‫ות‬

11. ‫ב‬ ‫המחלקות‬ ‫כתיבת‬ ‫לסדר‬ ‫חשיבות‬ ‫יש‬ ,‫כאמור‬‫בלוק‬try-catch‫הטיפוסים‬ ‫שסדר‬ ‫כך‬ ‫יוגדר‬ ‫הוא‬ ,‫כראוי‬ ‫יעבוד‬ ‫שזה‬ ‫מנת‬ ‫ועל‬
‫ה‬ ‫בבלוקי‬ ‫הממוקמים‬-catch‫היררכיית‬ ‫את‬ ‫הפוך‬ ‫באופן‬ ‫מתאר‬:‫דוגמה‬ ‫נראה‬ .)‫למעלה‬ ‫(מלמטה‬ ‫הירושה‬
try {
doSomething();
}
catch(GameProtocolException e) { }
catch(GameServerException e) { }
catch(Exception e) { }
‫ו‬ ‫היות‬‫ה‬ ‫לבלוקי‬ ‫הפנייה‬catch-‫ה‬ ‫פי‬ ‫על‬ ‫נעשית‬Code Flow-‫פי‬ ‫על‬ ,‫כלומר‬ ,‫סדר‬‫על‬ ‫מלשמור‬ ‫נמנע‬ ‫אם‬ ,‫הכתיבה‬‫סדר‬‫היררכי‬
‫של‬ ‫המיקום‬ ‫מבחינת‬ ‫הפוך‬‫בלוקי‬‫בלוקי‬ ‫בו‬ ‫למצב‬ ‫נגיע‬ ,‫אלו‬ ‫ם‬catch‫והטיפו‬ ‫משמעות‬ ‫חסרי‬ ‫הופכים‬‫ל‬‫בא‬ ‫לא‬ ‫בתוכם‬ ‫הנעשה‬
‫חסר‬ ‫והופך‬ ‫שימוש‬ ‫לידי‬‫משמעות‬,‫הבאה‬ ‫בצורה‬ ‫למשל‬:
try {
doSomething();
}
catch(GameServerException e) { }
catch(GameProtocolException e) { }
‫היות‬‫ו‬-GameProtocolException‫מ‬ ‫יורשת‬-GameServerException,‫אם‬‫תיזרק‬‫חריגה‬‫מטיפוס‬GameProtocolException,
‫היא‬‫תיתפס‬‫בבלוק‬‫הראשון‬(‫זה‬‫של‬GameServerException),‫משום‬‫כך‬,‫הבלוק‬‫של‬GameProtocolException‫כלל‬‫לא‬‫יהיה‬
‫נגיש‬.
,‫כן‬ ‫אם‬‫מתודה‬ ‫של‬ ‫באפשרותה‬‫לזרוק‬‫חריגה‬‫מכל‬‫טיפוס‬‫עליו‬‫היא‬‫הכריזה‬(...throws)‫מ‬ ‫חריגות‬ ‫לזרוק‬ ,‫כן‬ ‫וכמו‬‫טיפוס‬‫ים‬
‫שיורש‬‫ים‬‫מ‬‫ה‬ ‫אותו‬‫טיפוס‬‫עליו‬‫היא‬‫הכריזה‬.‫אם‬‫מתודה‬‫הכריזה‬‫על‬‫זריקה‬‫של‬‫חריגה‬,‫בבלוק‬‫ה‬-try-catch‫את‬ ‫שמפעיל‬
‫החריגה‬ ‫אותה‬ ,‫המתודה‬‫חייבת‬‫ל‬‫הית‬‫פס‬‫בלוק‬ ‫ע"י‬catch‫מתאים‬–‫שמקבל‬ ‫כזה‬‫חריגה‬‫מטיפוס‬‫זה‬‫או‬‫מטיפוס‬‫שנמצא‬‫גבוה‬
‫יותר‬‫בסולם‬‫הירושה‬‫בלוק‬ ‫קיים‬ ‫שלא‬ ‫היא‬ ‫המשמעות‬ ,‫אחרת‬ ,catch‫בחריגה‬ ‫לטפל‬ ‫שמתאים‬.
‫נ‬ ‫כי‬ ,‫לב‬ ‫נשים‬‫יתן‬‫לתפוס‬‫בבלוק‬try-catch‫חריגות‬‫שנמצאות‬‫במקומות‬‫שונים‬‫באותו‬‫סולם‬‫ירושה‬‫שכל‬ ‫מנת‬ ‫על‬ ,‫זאת‬ ‫עם‬ ,
‫בלוקי‬‫ה‬-catch‫עבור‬ ‫בלוקים‬ ‫ראשית‬ ‫למקם‬ ‫לדאוג‬ ‫יש‬ ,‫נגישים‬ ‫יהיו‬‫המחלקות‬‫שנמצאות‬‫במקום‬‫נמוך‬‫יותר‬‫בסולם‬‫הירושה‬
‫מ‬ ‫בלוקים‬ ‫מכן‬ ‫לאחר‬ ‫ורק‬‫תאימים‬‫עבור‬‫החריגות‬‫שנמצאות‬‫גבוה‬‫מהם‬‫הוא‬ ‫שיקרה‬ ‫מה‬ ,‫הפוך‬ ‫יהיה‬ ‫המקרה‬ ‫אם‬ ‫שהרי‬ ,
‫ש‬‫ה‬ ‫בבלוק‬ ‫לה‬ ‫הייעודי‬ ‫הטיפול‬ ‫את‬ ‫לקבל‬ ‫תגיע‬ ‫לא‬ ‫אך‬ ,)‫הורשה‬ ‫(מבחינת‬ ‫המתאים‬ ‫הראשון‬ ‫בבלוק‬ ‫תיתפס‬ ‫החריגה‬‫ממוקם‬
‫יותר‬ ‫נמוך‬‫ובשל‬‫תתקמפל‬ ‫לא‬ ‫התוכנית‬ ‫כך‬.
‫בלוקי‬ '‫למס‬ ‫שונות‬ ‫בחריגות‬ ‫הטיפול‬ ‫את‬ ‫להפריד‬ ‫ניתן‬ ‫כיצד‬ ‫ראינו‬ ‫הנ"ל‬ ‫בדוגמה‬catch‫זה‬ ‫אך‬ ,‫הירושה‬ ‫להיררכיית‬ ‫בהתאם‬
‫במשפט‬ ‫לתפוס‬ ‫תהיה‬ ‫הכללית‬ ‫שההמלצה‬ ‫לציין‬ ‫המקום‬catch‫אותו‬ ‫את‬ ‫לכולן‬ ‫לתת‬ ,‫אפשר‬ ‫ובאם‬ ‫חריגות‬ ‫של‬ ‫קבוצה‬ ‫אחד‬
‫הטיפול‬-.‫בקוד‬ ‫לחסוך‬ ‫נוכל‬ ‫כזה‬ ‫באופן‬
‫מטיפוס‬ ‫חריגה‬ ‫של‬ ‫תפיסה‬ ‫הוא‬ ‫שימושית‬ ‫תהיה‬ ‫כזו‬ ‫טכניקה‬ ‫בו‬ ‫למקרה‬ ‫דוגמה‬IOException‫לחריגות‬ ‫בסיס‬ ‫מהווה‬ ‫אשר‬ ,
:‫הבא‬ ‫באופן‬ ‫נתונים‬ ‫של‬ ‫קלט/פלט‬ ‫תקלות‬ ‫כולן‬ ‫ומתארות‬ ‫ממנה‬ ‫שיורשות‬ ‫רבות‬
catch(IOException e) {
}
‫משפט‬catch.‫ממנו‬ ‫שירשו‬ ‫הטיפוסים‬ ‫אותם‬ ‫ומכל‬ ‫הטיפוס‬ ‫מאותו‬ ‫חריגות‬ ‫יתפוס‬ ‫בעצם‬ ‫כזה‬

12. ‫טיפול‬ ‫לתת‬ ‫נרצה‬ ,‫לעתים‬‫מסוי‬ ‫לחריגה‬ ‫חלקי‬‫מלא‬ ‫טיפול‬ ‫לבצע‬ ‫שלנו‬ ‫האחריות‬ ‫בתחום‬ ‫לא‬ ‫שזה‬ ‫מכיוון‬ ‫נובע‬ ‫לרוב‬ ‫זה‬ ‫רצון‬ .‫מת‬
.‫בבעיה‬‫אותה‬ ‫ולזרוק‬ ‫מעוניינים‬ ‫שאנו‬ ‫הנתונים‬ ‫את‬ ‫לה‬ ‫להוסיף‬ ‫או‬ ‫ממנה‬ ‫לקחת‬ ,‫חריגה‬ ‫לתפוס‬ ‫ביכולתנו‬ ‫יש‬ ,‫שכאלו‬ ‫במקרים‬
‫בהנחה‬ .‫טיפול‬ ‫להמשך‬ ‫יותר‬ ‫גבוה‬ ‫במקום‬ ‫תיתפס‬ ‫שהיא‬ ‫בכדי‬ ‫שוב‬‫בלוק‬ ‫וקיים‬catch,‫החריגה‬ ‫אותה‬ ‫עבור‬‫באותה‬ ‫לטפל‬ ‫ניתן‬
‫ב‬ ‫טיפול‬ ‫להמשך‬ ‫אותה‬ ‫ולהעביר‬ ‫הראשוני‬ ‫הטיפול‬ ‫את‬ ‫החריגה‬)‫למשל‬ ‫אחרת‬ ‫(מתודה‬ ‫ההיררכיה‬ ‫מעלה‬:‫כך‬ ,
catch(PrinterIOException e) {
System.out.println("Printer I/O errors gets this message!");
throw e;
}
catch(PrinterException e) {
System.out.println("Other printer errors gets this message!");
}
‫מטיפוס‬ ‫חריגה‬ ‫ונזרקה‬ ‫ובהנחה‬PrinterIOException‫למסך‬ ‫יודפס‬ ,(‫שוב‬ ‫תיזרק‬ ‫והחריגה‬):
Printer I/O errors gets this message!
‫כה‬ ‫עד‬ ‫הנאמר‬ ‫את‬ ‫ויזואלית‬ ‫המתאר‬ ‫בתרשים‬ ‫נביט‬‫נראה‬ ‫הנתונה‬ ‫המחלקות‬ ‫להיררכיית‬ ‫ובהתאם‬‫להמחשה‬ ‫דוגמאות‬:
‫מטיפוס‬ ‫חריגה‬ ‫ונזרקה‬ ‫בהנחה‬rrorE:
‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬‫בלוק‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬Error
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬Throwable
‫מטיפוס‬ ‫חריגה‬ ‫ונזרקה‬ ‫בהנחה‬MyFirstException:
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬MyFirstException
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬Exception
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬Throwable
‫מטיפוס‬ ‫חריגה‬ ‫ונזרקה‬ ‫בהנחה‬MySecondException:
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬MySecondException
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬MyFirstException
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬Exception
‫בלוק‬ ‫לתפוס‬ ‫יוכל‬ ‫זו‬ ‫חריגה‬catch‫מטיפוס‬ ‫חריגות‬ ‫שתופס‬Throwable

13. ‫חדש‬ ‫מטיפוס‬ ‫חריגות‬
‫מחלקות‬ ‫לכתוב‬ ‫המתכנת‬ ‫באפשרות‬ .‫תקלה‬ ‫של‬ ‫סוג‬ ‫כל‬ ‫לתאר‬ ‫מנת‬ ‫על‬ ‫במערכת‬ ‫המובנות‬ ‫בחריגות‬ ‫להסתפק‬ ‫נוכל‬ ‫תמיד‬ ‫לא‬
.‫חריגות‬ ‫המהוות‬ ‫חדשות‬‫מחלקות‬ ‫של‬ ‫כתיבה‬‫ה‬ ‫זה‬ ‫מסוג‬:‫מאוד‬ ‫פשוטה‬ ‫יא‬‫ליצור‬ ‫מעוניינים‬ ‫אנו‬ ‫האם‬ ‫להחליט‬ ‫עלינו‬ ‫ראשית‬
‫מסוג‬ ‫חריגה‬Checked Exception‫מסוג‬ ‫חריגה‬ ‫או‬Unchecked Exception‫ליצור‬ ‫שברצוננו‬ ‫במקרה‬ .Checked Exception,
‫מהמחלקה‬ ‫שיורשת‬ ‫מחלקה‬ ‫ליצור‬ ‫עלינו‬Exception‫ליצור‬ ‫שברצוננו‬ ‫ובמקרה‬Unchecked Exception‫מחלקה‬ ‫ליצור‬ ‫עלינו‬ ,
‫מ‬ ‫שיורשת‬-RuntimeException.
‫ב‬‫מחלקה‬Exception‫קיימות‬‫ארבע‬‫בונות‬ ‫מתודות‬(‫קונסטרקטורים‬)‫אותן‬‫לדרוס‬ ‫ניתן‬‫במ‬‫ידה‬‫ונרצה‬‫שמתנהג‬ ‫כאלו‬ ‫לקבל‬‫ות‬
‫שונה‬ ‫באופן‬‫מהמקור‬.
‫הבאה‬ ‫בדוגמה‬ ‫נתבונן‬ ,‫יותר‬ ‫טובה‬ ‫בצורה‬ ‫הנושא‬ ‫את‬ ‫להבין‬ ‫מנת‬ ‫על‬:
public class MyFirstException extends Exception {
/**
* Serial Number
*/
private static final long serialVersionUID = -7000000000000000000L;
/**
* Constructor with no parameters
*/
public MyFirstException() {}
/**
* @param arg0 Error message
*/
public MyFirstException(String arg0) {
super(arg0);
}
/**
* @param arg0 Nested exception
*/
public MyFirstException(Throwable arg0) {
super(arg0);
}
/**
* @param arg0 Error message
* @param arg1 Nested exception
*/
public MyFirstException(String arg0, Throwable arg1) {
super(arg0, arg1);
}
}
‫מחלקה‬‫זו‬‫לא‬‫מוסיפה‬‫דבר‬‫למחלקה‬Exception‫נ‬ ‫אך‬ ,‫הנוכחית‬ ‫בתצורתה‬‫וכל‬‫בין‬ ‫להבחין‬ ‫ע"מ‬ ‫בה‬ ‫להשתמש‬‫סוגי‬‫החריגות‬
‫שייזרקו‬.,‫כן‬ ‫כמו‬‫ניתן‬‫ליצור‬‫מחלקות‬‫ש‬‫זו‬ ‫ממחלקה‬ ‫יורשות‬‫במטרה‬‫להבחין‬‫בין‬‫מ‬ ‫תקלות‬‫סוגים‬‫שונים‬.
‫במידה‬‫ונרצה‬‫להוסיף‬‫אפשרויות‬‫שונות‬‫למחלקה‬‫נוכל‬ ,‫גם‬‫לשנות‬‫את‬‫ה‬.‫שלה‬ ‫הבונות‬ ‫מתודות‬

14. ‫נניח‬,‫לדוגמה‬,‫ש‬‫להוסיף‬ ‫נוכל‬ ,‫זה‬ ‫במקרה‬ .‫חריג‬ ‫כמקרה‬ ‫חריגה‬ ‫של‬ ‫זריקה‬ ‫אי‬ ‫לתאר‬ ‫ברצוננו‬‫את‬‫המיל‬‫ים‬"No Exception:"
‫לפני‬‫תיאור‬‫של‬‫כל‬‫חריגה‬‫שנזרקת‬‫שלנו‬ ‫מהמחלקה‬.
‫במקרה‬‫זה‬,‫המתודה‬ ‫את‬ ‫נוסיף‬:
private static String printNoException(String message) {
return "No Exception: "+message;
}
‫ונ‬‫בצע‬‫הבאים‬ ‫השינויים‬ ‫את‬‫במ‬‫תודות‬:
public MySecondException(String message) {
super(printNoException(message));
}
public MySecondException(String message, Throwable cause) {
super(printNoException(message), cause);
}
:‫הבאה‬ ‫המחלקה‬ ‫הגדרת‬ ‫שתתקבל‬ ‫כך‬
public class MySecondException extends MyFirstException {
/**
* Serial Number
*/
private static final long serialVersionUID = -8000000000000000000L;
/**
* @param arg0 Error message
*/
public MySecondException(String message) {
super(printNoException(message));
}
/**
* @param arg0 Error message
* @param arg1 Nested exception
*/
public MySecondException(String message, Throwable cause) {
super(printNoException(message), cause);
}
/**
* @param message
*/
private static String printNoException(String message) {
return "No Exception: "+message;
}
}
:‫שיצרנו‬ ‫בחריגה‬ ‫נשתמש‬ ,‫כעת‬

15. public class ExceptionExample5 {
public static void main(String[] args) {
int arrayOfInt[] = {0, 1, 2};
for(int index=1; index <= arrayOfInt.length; index++) {
try {
System.out.println(arrayOfInt[index]);
throw new MySecondException("No array index out of bounds
exception thrown yet!");
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("nIndex not in range!");
}
catch (MySecondException e) {
System.out.println("Second Exception Thrown:");
System.out.println(e.getClass());
System.out.println(e.getMessage());
}
finally {
System.out.println("This will print anyway!");
}
}
}
}
:‫הפלט‬ ‫שיתקבל‬ ‫כך‬
1
Second Exception Thrown:
class MySecondException
No Exception: No array index out of bounds exception thrown yet!
This will print anyway!
2
Second Exception Thrown:
class MySecondException
No Exception: No array index out of bounds exception thrown yet!
This will print anyway!
Index not in range!
This will print anyway!

16. ‫לתת‬ ‫ברצוני‬ ,"‫מדי‬ ‫"יבשה‬ ‫הייתה‬ ‫הקודמת‬ ‫שהדוגמה‬ ‫למקרה‬)‫קודם‬ ‫בקצרה‬ ‫(הוזכרה‬ ‫נוספת‬ ‫דוגמה‬–
‫סכי‬ ‫זוהי‬‫בלבד‬ ‫הקונספט‬ ‫הבנת‬ ‫למטרת‬ ‫המיועדת‬ ,‫רעיונית‬ ‫כללית‬ ‫מה‬:
‫מתודה‬ ‫וכתבנו‬ ‫נניח‬retrieve()‫קובץ‬ ‫שמקבלת‬XML.‫נתונים‬ ‫ממנו‬ ‫ושואבת‬ ‫ברשת‬ ‫ממקור‬
,‫כן‬ ‫כמו‬‫נניח‬‫ש‬‫ה‬ ‫קובץ‬ ‫פורמט‬-XML‫השתנה‬ ‫מהשרת‬ ‫שמגיע‬‫המפתחים‬ ‫ע"י‬‫בסדר‬ ‫עבר‬ ‫הכול‬ ,‫לכאורה‬ .–‫הורדת‬ ,‫ההתחברות‬
‫מסוים‬ ‫נתון‬ ‫לשלוף‬ ‫נצפה‬ ‫כאשר‬ ‫זאת‬ ‫נגלה‬ ‫אנו‬ .‫שונה‬ ‫פורמט‬ ‫בעל‬ ,‫כאמור‬ ,‫שירד‬ ‫הקובץ‬ ‫אך‬ ...'‫וכו‬ ‫בדיסק‬ ‫המקום‬ ,‫הקובץ‬
‫לא‬ ‫כבר‬ ‫שאולי‬...‫אחר‬ ‫משתנה‬ ‫שם‬ ‫תחת‬ ‫שקיים‬ ‫או‬ ,‫קיים‬
‫פורמטים‬ ‫בין‬ ‫שוני‬ ‫על‬ ‫להתריע‬ ‫שמטרתה‬ ,‫חדשה‬ ‫חריגה‬ ‫לבנות‬ ‫נוכל‬ ‫שכאלו‬ ‫מקרים‬ ‫עבור‬‫ק‬ ‫של‬‫ובץ‬XML‫לקובץ‬ ‫המצופה‬XML
‫נתון‬.
‫המתודה‬ ‫בתוך‬retrieve():‫הבא‬ ‫באופן‬ ‫החריגה‬ ‫את‬ ‫לזרוק‬ ‫נוכל‬
if (!myObject.match(newObject)) {
throw new XMLFormatException("XML files format doesn't match!");
}
‫ריצה‬ ‫בשגיאת‬ ‫ומדובר‬ ‫היות‬‫שכזו‬ ‫בחריגה‬ ‫לטפל‬ ‫שנרצה‬ ‫להיות‬ ‫מאוד‬ ‫יכול‬ ,‫זאת‬ ‫עם‬ ‫אך‬ ,‫החריגה‬ ‫אותה‬ ‫על‬ ‫הכרזה‬ ‫חובת‬ ‫אין‬ ,
‫ה‬ ‫לקבלת‬ ‫בקשה‬ ‫ע"י‬ ,‫(למשל‬-XML,‫ולכן‬ )‫הקיים‬ ‫לפורמט‬ ‫החדש‬ ‫הפורמט‬ ‫של‬ ‫המרה‬ ‫ביצוע‬ ‫או‬ ,‫אחר‬ ‫ממקור‬‫נוכל‬‫את‬ ‫להציב‬
:‫כך‬ ‫למתודה‬ ‫הקריאה‬
try {
retrieve();
}
:‫הבא‬ ‫באופן‬ ,‫זה‬ ‫מסוג‬ ‫חריגות‬ ‫שיתפוס‬ ‫בלוק‬ ‫להציב‬ ‫ואחריו‬
catch (XMLFormatException e) {
fix(newObject);
}
‫סיכום‬
‫הר‬ ‫בכל‬ ‫כמו‬‫אחרת‬ ‫מחלקה‬ ‫של‬ ‫חבה‬-‫לה‬ ‫ניתן‬‫עמיס‬‫בונות‬ ‫מתודות‬‫ולהוסיף‬‫ומשתנים‬ ‫מתודות‬‫נוספים‬.
,‫חריגה‬ ‫המתארת‬ ‫מחלקה‬ ‫בבניית‬‫לבצע‬ ‫לה‬ ‫לתת‬ ‫ולא‬ ‫בלבד‬ ‫המחלקה‬ ‫לפעולת‬ ‫שרלוונטיות‬ ‫פעולות‬ ‫ביצוע‬ ‫על‬ ‫לשמור‬ ‫רצוי‬
.‫בתכנית‬ ‫אחרות‬ ‫מחלקות‬ ‫ע"י‬ ‫לביצוע‬ ‫שמתאימות‬ ‫פעולות‬
‫חריג‬ ‫שמתארת‬ ‫שמחלקה‬ ‫נרצה‬ ‫לא‬ :‫לדוגמה‬‫ת‬‫שגיא‬‫ה‬‫ב‬‫רק‬ ‫אלא‬ ,‫מחדש‬ ‫חיבור‬ ‫ליצור‬ ‫ותנסה‬ ‫בבעיה‬ ‫תטפל‬ ,‫לרשת‬ ‫חיבור‬
‫על‬ ‫שתודיע‬.‫מסודר‬ ‫לוג‬ ‫בקובץ‬ ‫אותה‬ ‫ותתעד‬ ‫התקלה‬
‫נציין‬‫אצבע‬ ‫כלל‬‫בחריגה‬ ‫הטיפול‬ ‫את‬ :‫בנושא‬‫יש‬‫אות‬ ‫שיתפוס‬ ‫מי‬ ‫בידי‬ ‫תמיד‬ ‫להשאיר‬‫ה‬.
.‫מקרה‬ ‫בכל‬ ‫אותה‬ ‫ולתפוס‬ ‫לנסות‬ ‫צורך‬ ‫אין‬ ‫אז‬ ,‫להתאושש‬ ‫דרך‬ ‫אין‬ ‫ממנה‬ ‫בחריגה‬ ‫מדובר‬ ‫אם‬ :‫נוסף‬ ‫אצבע‬ ‫כלל‬