כיצד להתמודד עם חריגים מ- Java בדרך הנכונה

IllegalArgumentException
כדי לתפוס את החריג הזה, עליך ללכת לאן
someMethod()
נקרא והשתמש ב- בלוק נסה לתפוס :
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 }  
 // ...  
}
הכל בתוך לְנַסוֹת החסימה תבוצע לפי הסדר עד להשלכת חריג. ברגע שנזרקת חריגה, כל ההצהרות הבאות מדלגות והגיון היישום קופץ מיד אל לתפוס לַחסוֹם.
 
בדוגמה שלנו, אנו נכנסים לחסימת הניסיון ומיד מתקשרים
someMethod()
. מכיוון ש -200 אינו בין 0 ל -100, א
IllegalArgumentException
נזרק. זה מסיים מיד את ביצוע
someMethod()
, מדלג על שאר ההיגיון בבלוק הניסיון (
someOtherMethod()
לעולם אינו נקרא), ומחדש את הביצוע בתוך בלוק התפיסה.
 
מה היה קורה אם היינו מתקשרים
someMethod(50)
במקום זאת? ה
IllegalArgumentException
לעולם לא יזרקו.
someMethod()
יתבצע כרגיל. חסימת הניסיון תתבצע כרגיל, מתקשרת
someOtherMethod()
כאשר someMethod () משלים. מתי
someOtherMethod()
מסתיים, חוסם את בלוק התפיסה ו
callingMethod()
היה ממשיך.
 
שים לב שאתה יכול לקבל מספר בלוקים לתפוס לכל בלוק ניסיון:
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 } catch (NullPointerException e) {  
 // handle the exception in here  
 }  
 // ...  
}
שים לב גם כי אופציונלי סוף כל סוף הבלוק קיים גם כן:
public void method() {  
 try {  
 // ...  
 } catch (Exception e) {  
 // ...  
 } finally {  
 // ...  
 }  
}
הקוד בתוך בלוק סופי הוא תמיד הוצא להורג לא משנה מה. אם יש לך הצהרת החזרה בגוש הניסיון, הבלוק לבסוף מבוצע לפני החזרה מהשיטה. אם אתה זורק חריג נוסף בגוש התפיסה, הגוש לבסוף מבוצע לפני שהחריגה נזרקת.
 
עליך להשתמש בלוק לבסוף כאשר יש לך אובייקטים שצריך לנקות אותם לפני שהשיטה מסתיימת. לדוגמה, אם פתחת קובץ בגוש הניסיון ולאחר מכן זרקת חריג, החסימה לבסוף מאפשרת לך לסגור את הקובץ לפני שעזבת את השיטה.
 
שים לב שאתה יכול לקבל בלוק סופי ללא חסימה:
public void method() {  
 try {  
 // ...  
 } finally {  
 // ...  
 }  
}
זה מאפשר לך לבצע את כל הניקוי הדרוש תוך מתן אפשרות לחריגים שנזרקו להפיץ את מחסנית הפנייה לשיטה (כלומר, אינך רוצה להתמודד עם החריג כאן אך עדיין עליך לנקות תחילה).
 
חריגים מסומנים לעומת לא מסומנים ב- Java
שלא כמו רוב השפות, ג'אווה מבחינה בין בודקים חריגים ו חריגים לא מסומנים (למשל, ל- C# יש חריגים לא מסומנים). חריג מסומן צריך להיתפס בשיטה שבה החריג נזרק או שהקוד לא יאסוף.
 
כדי ליצור חריג מסומן, הרחב מ
Exception
. כדי ליצור חריג לא מסומן, הרחב מ
RuntimeException
.
 
כל שיטה שזורקת חריג מסומן חייבת לציין זאת בחתימת השיטה באמצעות זורק מילת מפתח. מאז Java מובנה
IOException
הוא חריג מסומן, הקוד הבא לא יקבץ:
public void wontCompile() {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
תחילה עליך להצהיר כי הוא זורק חריג מסומן:
public void willCompile() throws IOException {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
שים לב שאפשר להכריז על שיטה כזריקה חריגה אך לעולם לא לזרוק חריגה. למרות זאת, עדיין יהיה צורך לתפוס את החריג, אחרת הקוד לא יורכב.
 
מתי עליך להשתמש בחריגים מסומנים או לא מסומנים?
 
התיעוד הרשמי של Java כולל דף בשאלה זו . היא מסכמת את ההבדל עם כלל אצבע תמציתי: 'אם ניתן לצפות מהלקוח להתאושש מחריגה, הפוך אותו לחריג מסומן. אם לקוח לא יכול לעשות דבר כדי להתאושש מהחריג, הפוך אותו לחריג בלתי מסומן. '
 
אבל הנחיה זו עשויה להיות מיושנת. מצד אחד, חריגים מסומנים גורמים לקוד חזק יותר. מצד שני, אף שפה אחרת לא בדקה יוצאים מן הכלל באותו אופן כמו ג'אווה, המראה שני דברים: האחד, התכונה לא מספיק שימושית כדי ששפות אחרות יגנבו אותה, ושניים, אתה בהחלט יכול לחיות בלעדיהם. בנוסף, חריגים מסומנים אינם משחקים יפה עם ביטויי lambda שהוצגו ב- Java 8.
 
הנחיות לשימוש בחריגות Java
 
יוצאי דופן הם שימושיים אך משתמשים בהם בקלות לרעה ומתעללים בהם. להלן מספר עצות ושיטות מומלצות שיסייעו לך להימנע מבלגן.
 
 
  העדיפו חריגים ספציפיים על חריגים כלליים. השתמש | _+_ | מעל | _+_ | במידת האפשר, אחרת השתמש | _+_ | מעל | _+_ | כשמתאפשר.
 
  לעולם אל תתפס | _+_ | ! ה | _+_ | הכיתה למעשה מתרחבת | _+_ | , ובלוק התפיסה למעשה עובד עם | _+_ | או כל כיתה המשתרעת לזרוק. עם זאת, | _+_ | הכיתה מתרחבת גם | _+_ | , ואתה אף פעם לא רוצה לתפוס | _+_ | כי | _+_ | s מצביעים על בעיות חמורות שאינן ניתנות לשחזור.
 
  לעולם אל תתפס | _+_ | ! | _+_ | מרחיב | _+_ | , אז כל בלוק שתופס | _+_ | יתפוס גם | _+_ | , וזה יוצא מן הכלל חשוב מאוד שאינך רוצה להתעסק איתו (במיוחד ביישומים מרובי שרשורים) אלא אם כן אתה יודע מה אתה עושה. אם אינך יודע איזה חריג לתפוס במקום זאת, שקול לא לתפוס דבר.
 
  השתמש בהודעות תיאוריות כדי להקל על איתור באגים. כאשר אתה זורק חריג, תוכל לספק | _+_ | הודעה כטיעון. ניתן לגשת להודעה זו בלוק התפיסה באמצעות | _+_ | שיטה, אך אם החריג לעולם לא יתפס, ההודעה תופיע גם כחלק ממעקב הערימה.
 
  נסה לא לתפוס ולהתעלם מחריגים. כדי לעקוף את אי הנוחות שבחריגים שנבדקו, הרבה מתכנתים חדשים ועצלנים יקימו בלוק תפיסה אך ישאירו אותו ריק. רַע! תמיד לטפל בזה בחינניות, אך אם אינך יכול, לכל הפחות הדפס עקבות מחסנית כדי שתדע שהחריג נזרק. אתה יכול לעשות זאת באמצעות | _+_ | שיטה.
 
  היזהרו משימוש יתר בחריגים. כשיש לך פטיש, הכל נראה כמו מסמר. כאשר אתה לומד לראשונה על חריגים, אתה עלול להרגיש מחויב להפוך הכל לחריג ... עד לנקודה שבה רוב זרימת הבקרה של היישום שלך מסתכמת בטיפול בחריגים. זכור, יוצאי דופן מיועדים להתרחשויות 'יוצאות דופן'!
 
 
עכשיו אתה צריך להרגיש בנוח מספיק עם יוצאי דופן כדי להבין מה הם, מדוע משתמשים בהם וכיצד לשלב אותם בקוד שלך. אם אתה לא לגמרי מבין את הרעיון, זה בסדר! לקח לי זמן עד שזה 'לחץ' בראש שלי, אז אל תרגיש שאתה צריך למהר עם זה. קח את הזמן.
 
  יש לך שאלות? מכירים עוד טיפים הקשורים לחריגה שפספסתי? שתף אותם בתגובות למטה!  
  לַחֲלוֹק    לַחֲלוֹק      צִיוּץ      אימייל      כיצד ליצור תרשים זרימת נתונים לוויזואליזציה של נתונים מכל פרויקט  
תרשימי זרימת נתונים (DFD) של כל תהליך עוזרים לך להבין כיצד נתונים זורמים מהמקור ליעד. הנה איך ליצור את זה!
קרא הבא   נושאים קשורים  
 
תִכנוּת
 
ג'אווה
 
  על הסופר   ג'ואל לי(1524 מאמרים פורסמו)            
ג'ואל לי הוא העורך הראשי של MakeUseOf מאז 2018. יש לו תואר B.S. במדעי המחשב ומעל תשע שנות ניסיון בכתיבה ועריכה מקצועיות.
כיצד אוכל לעדכן את חנות Google Play שלי
עוד מאת ג'ואל לי
הירשם לניוזלטר שלנו
 
הצטרף לניוזלטר שלנו לקבלת טיפים, סקירות, ספרים אלקטרוניים בחינם ומבצעים בלעדיים!
לחצו כאן להרשמה