חריג מצביע NULL ב-JAVA

NullPointerException ב-Java הוא RuntimeException. זה מתרחש כאשר תוכנית מנסה להשתמש בהפניה לאובייקט בעל הערך null. ב-Java 'null' הוא ערך מיוחד שניתן להקצות להפניות לאובייקט כדי לציין היעדר ערך.

סיבות לחריג מצביע Null

NullPointerException מתרחשת מהסיבות הבאות:

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

דוּגמָה:

Java

    public     class   Geeks     {          public     static     void     main  (  String  []     args  )     {          // Reference set to null      String     s     =     null  ;             System  .  out  .  println  (  s  .  length  ());         }   }

תְפוּקָה:

 Hangup (SIGHUP)   
 Exception in thread 'main' java.lang.NullPointerException   
  at Geeks.main(Geeks.java:10)      הֶסבֵּר:    בדוגמה זו ההפניה למחרוזת 's' היא null. כאשר התוכנית מנסה לקרוא למתודה length() היא זורקת NullPointerException כי אין אובייקט ממשי.  
  מדוע נעשה שימוש ב-null ב-Java?  
  הערך null משמש כמציין מיקום והוא מציין שלא מוקצה ערך למשתנה התייחסות. יישומים נפוצים כוללים:  
      מבני נתונים מקושרים    : זה מייצג את סוף רשימה או ענף עץ.  
     דפוסי עיצוב    : זה משמש בתבניות כמו תבנית אובייקט Null או תבנית Singleton.  
 
  כיצד להימנע מ- NullPointerException  
  כדי להימנע מה-NullPointerException עלינו לוודא שכל האובייקטים מאותחלים כראוי לפני שנשתמש בהם. כאשר אנו מכריזים על משתנה התייחסות עלינו לוודא שהאובייקט אינו null לפני שאנו מבקשים שיטה או שדה מהאובייקטים.  
  1. שימוש ב-string letterals ב-equals()  
  בעיית מקרה נפוצה מאוד כרוכה בהשוואה בין משתנה מחרוזת למילולי. המילולי עשוי להיות מחרוזת או אלמנט של Enum. במקום להפעיל את השיטה מהאובייקט null שקול להפעיל אותה מהמילה המילולי.   
     דוּגמָה:    
 Java      import     java.io.*  ;   class   Geeks     {      public     static     void     main     (  String  []     args  )     {          // Initializing String variable with null value      String     s     =     null  ;      // Checking if s.equals null      try      {      // This line of code throws NullPointerException because s is null      if     (  s  .  equals  (  'gfg'  ))      System  .  out  .  print  (  'Same'  );      else         System  .  out  .  print  (  'Not Same'  );      }      catch  (  NullPointerException     e  )      {      System  .  out  .  print  (  'NullPointerException Caught'  );      }      }   }   
    
  תְפוּקָה   NullPointerException Caught 
  אנו יכולים להימנע מ- NullPointerException על ידי קריאה ל-equivalent על מילולית ולא על אובייקט.  
 Java      import     java.io.*  ;   class   Geeks     {      public     static     void     main     (  String  []     args  )     {          // Initializing String variable with null value      String     s     =     null  ;      // Checking if s is null using try catch      try      {      if     (  'gfg'  .  equals  (  s  ))      System  .  out  .  print  (  'Same'  );      else         System  .  out  .  print  (  'Not Same'  );         }      catch  (  NullPointerException     e  )      {      System  .  out  .  print  (  'Caught NullPointerException'  );      }      }   }   
    
  תְפוּקָה   Not Same 
     פֶּתֶק    : הפעל תמיד שווים על המילולי כדי להימנע מקריאת מתודה בהפניה אפסית.  
  2. בדיקת טיעוני שיטה  
  לפני ביצוע הגוף של השיטה החדשה, עלינו לבדוק תחילה את הארגומנטים שלה עבור ערכי null ולהמשיך בביצוע השיטה רק כאשר הארגומנטים נבדקים כראוי. אחרת הוא יזרוק IllegalArgumentException ויודיע לשיטת הקריאה שמשהו לא בסדר עם הארגומנטים שעברו.   
     דוּגמָה:    
 Java      import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )     {          // String s set an empty string and calling getLength()      String     s     =     ''  ;          try     {      System  .  out  .  println  (  getLength  (  s  ));      }      catch     (  IllegalArgumentException     e  )     {      System  .  out  .  println  (      'IllegalArgumentException caught'  );      }      // String s set to a value and calling getLength()      s     =     'GeeksforGeeks'  ;          try     {      System  .  out  .  println  (  getLength  (  s  ));      }      catch     (  IllegalArgumentException     e  )     {      System  .  out  .  println  (      'IllegalArgumentException caught'  );      }      // Setting s as null and calling getLength()      s     =     null  ;          try     {      System  .  out  .  println  (  getLength  (  s  ));      }      catch     (  IllegalArgumentException     e  )     {      System  .  out  .  println  (      'IllegalArgumentException caught'  );      }      }      public     static     int     getLength  (  String     s  )      {      if     (  s     ==     null  )      throw     new     IllegalArgumentException  (      'The argument cannot be null'  );          return     s  .  length  ();      }   }   
    
  תְפוּקָה   0 13 IllegalArgumentException caught  
  3. השתמש ב-Ternary Operator  
  ניתן להשתמש באופרטור הטרינרי כדי להימנע מ- NullPointerException. תחילה מוערך הביטוי הבוליאני. אם הביטוי נכון אז הערך 1 מוחזר אחרת הערך 2 מוחזר. אנו יכולים להשתמש באופרטור הטרינרי לטיפול במצביעי null.  
     דוּגמָה:    
 Java      import     java.io.*  ;   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      String     s     =     null  ;      String     m     =     (  s     ==     null  )     ?     ''     :     s  .  substring  (  0       5  );      System  .  out  .  println  (  m  );      s     =     'Geeksforgeeks'  ;      m     =     (  s     ==     null  )     ?     ''     :     s  .  substring  (  0       5  );      System  .  out  .  println  (  m  );      }   }   
    
  תְפוּקָה   Geeks  
     הֶסבֵּר    : האופרטור השלישוני עוזר לבדוק אם יש null ולהימנע מפעולות על הפניות null.  
  4. שימוש בכיתה אופציונלית (Java 8+)  
  ב-Java 8 מחלקה אופציונלית הוצגה כאובייקט מיכל שעשוי להכיל או לא להכיל ערך שאינו ריק. זה עוזר להימנע     NullPointerException    על ידי אילוץ לטפל במפורש במקרה כאשר ערך נעדר.  
  דוּגמָה:  
 Java      import     java.util.Optional  ;   public     class   OptionalExample     {      public     static     void     main  (  String  []     args  )     {      Optional   <  String  >     name     =     Optional  .  ofNullable  (  null  );      // Safe way to access      System  .  out  .  println  (  name  .  orElse  (  'Default Name'  ));     // prints: Default Name      }   }   
    
  תְפוּקָה   Default Name  
     הֶסבֵּר:    Optional.ofNullable(value) עוטף את הערך שעשוי להיות null. orElse() מספק סתירה אם הערך אינו קיים.