Java Try - תפוס

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

ג'אווה נסה לתפוס בלוק

כאשר מתרחשת שגיאה, Java בדרך כלל נעצרת ויוצרת הודעת שגיאה. תהליך זה נקרא "ג'אווה זורקת חריג". Java מספקת מתקנים מיוחדים לטיפול בחריגים. אחד מהם הוא לנסות...לתפוס...סוף סוף בנייה. הנה התחביר של try block, catch block ולבסוף block.

//try block
try {
  // Block of code to try
}
//try catch
catch(Exception e) {
  // Block of code to handle errors
}
finally {
 // Optional block of code
          }

כאשר מתרחש חריג בבלוק ה-try, השליטה עוברת לבלוק ה-catch, שיכול להתמודד עם החריגה. אם לא נמצא בלוק כזה, הודעת חריגה לא מטופלת תוצג למשתמש וביצוע המשך של התוכנית נעצר. זה כדי למנוע עצירת חירום כזו שאתה צריך להשתמש בלוק try..catch.

בקצרה על לנסות, לתפוס, לבסוף, זורק מילות מפתח

טיפול בחריגים ב-Java מבוסס על השימוש במילות המפתח הבאות בתוכנית:

• try — מגדיר גוש קוד שבו יכול להתרחש חריג;
• catch - מגדיר את גוש הקוד שבו החריג מטופל;
• לבסוף - מגדיר גוש קוד שהוא אופציונלי, אך אם קיים, מבוצע בכל מקרה, ללא קשר לתוצאות של בלוק ה-try.

מילות מפתח אלו משמשות ליצירת מבני עיבוד מיוחדים בקוד התוכנית: try catch, and try catch finally}.

• throw - משמש להעלאת חריג;
• throws - משמש בחתימות שיטה כדי להזהיר שמתודה עלולה לזרוק חריג.

דוגמה קלה לבנייה בניסיון לתפוס

נניח שיש לנו תוכנית עם מערך כלשהו.

public class TryTest {
   public static void main(String[] args) {
       int[] myArray = new int[5];
       myArray[7] = 8;
       System.out.println(myArray[7]);
   }
}

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

//try catch example
public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
           System.out.println("The exception was handled...");
       }

       System.out.println("This is the end of the program...");
   }
}

כעת הפלט השתנה: במקרה זה, התוכנית הושלמה כהלכה, ההודעה שלנו מוצגת על המסך. סיום נכון של התוכנית מסומן על ידי קוד 0 בסוף התהליך, בעוד שגוי - 1. כאשר משתמשים בבלוק try...catch, כל ההצהרות בין הצהרות try ל-catch מבוצעות תחילה. אם מתרחש חריג בבלוק try, אזי פקודת הביצוע הרגילה נעצרת וממשיכה להצהרת ה-catch. לכן, כאשר הפעלת התוכנית מגיעה למספרים[7]=8; שורה, התוכנית תעצור ותעבור ל-catch block במקרה שלנו, הכרזנו על המשתנה myEx עם הסוג Exception. זוהי מחלקת הבסיס לכל החריגים, ולכן הם יכולים להיות שונים. לדוגמה, ישנם חריגים שאחראים להצפת מחסנית, מעבר לאינדקס המערך, כמו במקרה שלנו, מצביע על Null וכו'. אם לא היינו מנחשים עם סוג החריגה, אז גם התוכנית הייתה מסתיימת בצורה שגויה. עם זאת, בחרנו בסוג Exception לפשטות הדוגמה, והוא המחלקה הבסיסית לכל החריגים. אז הצהרת ה-catch (Exception myEx) תטפל כמעט בכל החריגים. טיפול בחריג במקרה זה לאחר סיום בלוק ה-catch, התוכנית ממשיכה בעבודתה, ומבצעת את כל שאר ההוראות לאחר בלוק ה-catch. אם ברצונך לראות חריגים שהתרחשו, תוכל לבקש מהתוכנית להדפיס עקבות מחסנית של קריאות למתודה. זה מה שה-JVM עושה כאשר מתרחש חריג שלא נתפס: הוא עוצר את ביצוע התוכנית, ומדפיס עקבות מחסנית לאחר ביצוע הקוד של הבלוק הסופי, אם קיים.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {

         myEx.printStackTrace();
       }

       System.out.println("This is the end of the program...");
   }
}

טיפול בחריג במקרה זה מסתכם בהדפסת ערימת מעקב השגיאה למסוף באמצעות השיטה printStackTrace() המוגדרת במחלקה Exception . עם זאת, התוכנית יצאה כראוי.

סוף כל סוף! לאחר תפיסה

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

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (NullPointerException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

הנה הפלט: אגב, אנחנו יכולים לציין את סוג החריגה להיות נכון. כאן זה IndexOutOfBoundsException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (IndexOutOfBoundsException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

במקרה זה, הפלט יהיה כדלקמן:

איך פועלים חריגים?

הנקודה היא שכל המילים האלה -תפוס, זרוק, זריקות יכולות לשמש רק עם java.lang.Throwable או צאצאיו. לדוגמה, אתה יכול לעשות זאת:

public class MyClass {
    public static void main(String[] args) {
        try {
        } catch (Throwable thr) {
}
    }
}

עם זאת, אתה לא יכול לעשות את זה ככה:

public class MyClass {
public static void main(String[] args) {
        try {
        } catch (String thr) {
}
    }
}