ההבדל בין זורק לזרוק בג'אווה
תוֹכֶן
הזריקות והזרקות הן מילות המפתח המשמשות בטיפול בחריגות. ה לזרוק מילת המפתח משמשת למסירת המופע של החריג שנוצר על ידי המתכנת ל- JVM באופן ידני. ה זורק מילת המפתח המשמשת למסירת האחריות לטיפול בחריג התרחשה בשיטה לשיטת המתקשר. ההבדל הבסיסי בין זורק לזריקות הוא שמילת המפתח משליכה את אובייקט החריגה ואילו מילת המפתח זורקת משתמשת בשיעור חריגות.
- טבלת השוואה
- הגדרה
- הבדלים עיקריים
- סיכום
טבלת השוואה
| בסיס השוואה | לזרוק | זורק |
|---|---|---|
| בסיסי | מסירת מילות המפתח מחלקת ידנית את אובייקט החריגה שלנו ל- JVM. | מילת המפתח משליכה משמשת להאצלת האחריות של הטיפול בחריגות למתקשר לשיטה. |
| תחביר | לזרוק מופע זרוק; | return_type method_name (רשימת פרמטרים) זורק את ExceptionClass_list { // גוף השיטה } |
| בא אחריו | אחרי מילת המפתח לזרוק אחריו אובייקט חריג. | אחרי מילת המפתח זורקת אחריה רשימת מחלקות החריגות שיכולות להופיע בשיטה. |
| מספר החריג שנזרק | מילת המפתח יכולה לזרוק מופע חריג יחיד. | מילת המפתח לזריקות יכולה להכריז על שיעורי חריגה מרובים המופרדים בפסיק. |
הגדרת זריקה
מילת המפתח "לזרוק"משמש למסירת ידנית של מופע החריגה שנוצר ל- JVM (Java Virtual Machine). אם "זריקה" אינה משמשת לזריקת מופע חריג והחריג מתרחש, מערכת זמן הריצה באופן פנימי זורקת את מופע החריג ל- JVM והתוכנית מסתיימת בצורה לא תקינה. הצורה הכללית של מילת המפתח היא:
לזרוק Throwable_instance;
מעל Throwable_instance חייב להיות אובייקט של הכיתה Throwable. לא ניתן לזרוק סוגים פרימיטיביים כמו int, float או char, ואת המופע הכיתה שאינו ניתן לזרוק באמצעות מילת המפתח.
ניקח דוגמא להבנת זריקת מילות המפתח.
מבחן מחלקה {main static void main (מחרוזת טענות) {לזרוק ArithmeticException חדש ("/ באפס"); }}
בקוד שלמעלה, זריקת מילות המפתח זורקת מופע משיעור החריג "ArithmeticException". אם לא נעשה שימוש במילת המפתח לזרוק, השיטה העיקרית () הייתה יוצרת באופן פנימי אובייקט חריג שנמסר ל- JVM.
הנקודות שיש לזכור על מילת המפתח:
- זה מוסר את אובייקט החריג באופן ידני ל- JVM.
- זה הכי טוב להשתמש עבור חריגים המוגדרים על ידי המשתמש או חריגים בהתאמה אישית.
- אם הזיכרון לא מוקצה לאובייקט החריגה שנזרק על ידי מילת מפתח לזרוק, נוצר חריג לזמן ריצה, NullPointerException.
- מילת המפתח זורקת מפסיקה את ביצוע התוכנית מיד לאחר התרחשותה. איננו יכולים לכתוב ישירות הצהרה כלשהי לאחר הצהרת השלכת. אם אנו כותבים איזשהו עמדה ישירות לאחר הצהרת השלכת, המהדר יציג הצהרה שגיאה, בלתי ניתנת להשגה במהלך ההרכבה.
- ניתן לזרוק רק אובייקטים מהמחלקה הניתנת לזריקה באמצעות מילת מפתח לזרוק. אם האובייקט שנזרק אינו מושא הניתן לזרוק בכיתה, נקבל שגיאת זמן קומפילציה "נמצא סוג לא תואם. . נדרש java.lang.Trowable ”
פתק:
מילת המפתח לזרוק משמשת ב- C ++, JAVA, C #, כדי לזרוק ידנית חריגה.
הגדרת זריקות
ה "זורקמילת המפתח משמשת להקצאת האחריות לטיפול בחריג שהתרחש בשיטה לשיטת המתקשר שלה. שיטת המתקשר אחראית על הטיפול בחריג שהיא יכולה להיות בכל שיטה אחרת או JVM. הוא מצהיר את רשימת מחלקות החריגות שעלולות להופיע בשיטה.
השימוש במילת המפתח זורק משכנע את המהדר כי החריג שהתרחש בשיטה אמור להיות מטופל על ידי שיטת המתקשר ומכאן שלא מתרחשת שגיאת קומפילציה. עם זאת, שיטת המתקשר חייבת להתמודד עם החריג או להאציל את האחריות לטפל בחריג לשיטת ההיררכיה שלה. כאשר חריגה בזמן ריצה מתרחשת, גם לאחר השימוש במילת מפתח לזריקות, זה לא מונע את סיומה הלא תקין של התוכנית. אם שיטת המתקשר היא עיקרית (), כברירת מחדל JVM מטפל בחריג.
הצורה הכללית של מילת המפתח זורקת היא:
return_type method_name (רשימת פרמטרים) זורק exceptionClass_list {// body of method}
אנו יכולים לראות שמילות מפתח זורקות מופיעות לאחר חתימת השיטה, והיא יכולה להכיל את רשימת שיעורי החריגות שעלולים להופיע בשיטה. רשימת שיעורי החריגה שנכתבה לאחר השלמת מילות המפתח מופרדת על ידי הפסיק.
ניקח דוגמא אחת להבנת מילת המפתח.
מבחן calss {main static void main (מחרוזת args) זורק את InterruptException {sleep thread (10000); }}
בקוד שלעיל החוט הראשי מורדם לישון זמן מה בשיטת השינה (). כעת, כאשר השיטה העיקרית היא בשינה, יתכן כי שאר החוטים עלולים להפריע לחוט הראשי. עם זאת, משתמשים במילת המפתח זורקת לאחר חתימת השיטה העיקרית () כך שהתוכנית תרכיב בקלות. מילת המפתח לזריקות מכריזה על כיתת החריגה שנבדקה InterruptException. כעת, אם כל חוט אחר קוטע את החוט הראשי בזמן ריצה, מילת המפתח תעביר את החריגה למתקשר לשיטת main (), שהיא JVM. ה- JVM היה מסיים את התוכנית בצורה לא תקינה.
הנקודות שיש לזכור לגבי מילות מפתח זורקות:
- מילת המפתח משליכה משמשת רק להצהרת שיעורי החריגים שנבדקו. השימוש במילת המפתח זורק למעט חריגה לא מסומן אינו משפיע.
- אם השיטה לא רוצה להתמודד עם החריג בכוחות עצמה, היא מאצילה את החריג הזה לשיטת המתקשר באותה הכיתה על ידי שימוש במילת המפתח.
- השימוש בו מאפשר רק אוסף חלק של התוכנית.
- אם חריגה מתרחשת בזמן ריצה, התוכנית מסתיימת בצורה לא תקינה, גם לאחר השימוש במילת המפתח.
- מומלץ להשתמש בלוק ה- try / catch לסיום רגיל של התוכנית אם יוצא חריג בזמן ריצה.
פתק:
מילות המפתח זורקות המשמשות רק ב- Java. C ++ ו- C # אינם משתמשים במילת המפתח.
- זריקת מילות המפתח, מסירה את האחריות לטיפול בחריגות באופן ידני ל- JVM ואילו מילת המפתח זורקת, מסירה את האחריות של הטיפול בחריג לשיטת המתקשר של הקוד בו התרחשה חריגה.
- אחרי מילת המפתח לזרוק אחריו אובייקט החריגה שהיא מוסרת ל- JVM. מצד שני, מילות מפתח זורקות אחריהן שיעורי החריגות שיכולים להופיע בשיטה.
- מילת המפתח יכולה לזרוק אובייקט חריג יחיד בכל פעם, בעוד שמילת המפתח יכולה להכריז על שיעורי חריגה מרובים המופרדים בפסיק בכל פעם.
סיכום:
מילת המפתח לזרוק משמשת באופן הטוב ביותר לחריג המותאם אישית. בלוק ה- try / catch הוא הטוב ביותר לטיפול בחריגים בהשוואה למילות מפתח שזורקות.
