In diesem Tutorial lernen wir die Nullzeiger-Ausnahme in Java kennen. Eine Nullzeigerausnahme ist eine Laufzeitausnahme. Null ist eine besondere Art von Wert, der der Referenz eines Objekts zugewiesen werden kann. Immer wenn versucht wird, eine Referenz zu verwenden, die den Nullwert hat, wird die NullPointerException ausgelöst.

Verschiedene Szenarien für die Nullzeiger-Ausnahme

Beobachten Sie einige der folgenden Szenarios, in denen eine NullPointerException ausgelöst werden kann.

• Berechnen der Größe oder Länge der Null, als wäre sie ein Array von Elementen.

Dateiname: ThrowNullExcep.java

 public class ThrowNullExcep { // main method public static void main(String args[]) { int arr[] = null; // array is assigned a null value System.out.println('The length of the array arr is: ' + arr.length); } } 

Ausgabe:

• Aufrufen einer Methode mit dem Objekt, das den Nullwert hat.

Dateiname: ThrowNullExcep1.java

Array in Java sortiert

 public class ThrowNullExcep1 { public void foo() { System.out.println('In the method foo.'); } public static void main(String args[]) { ThrowNullExcep1 obj = null; // assigning null value // invoking the method foo() obj.foo(); } } 

Ausgabe:

 Exception in thread 'main' java.lang.NullPointerException: Cannot invoke 'ThrowNullExcep1.foo()' because '' is null at ThrowNullExcep1.main(ThrowNullExcep1.java:13) 

• Wenn Sie versuchen, über ein NULL-Objekt zu synchronisieren.

Dateiname: ThrowNullExcep2.java

 // A Java program that synchronizes over a NULL object. import java.util.*; import java.io.*; // A Class that is required for sending the message class Sendr { public void sendMethod(String mssg) { System.out.println('Sending message: ' + mssg ); try { Thread.sleep(100); } catch (Exception exp) { System.out.println('Thread interrupted.' + exp); } System.out.println('
' + mssg + ' is sent'); } } // A Class that is used to send messages with the help of threads Threads class ThreadSend extends Thread { private String mssg; Sendr sendr; // Received a messge obj and the string // mssge that has to be sent ThreadSend(String mStr, Sendr obj) { mssg = mStr; sendr = obj; } public void run() { // Only a single thread is allowed to send a message // at a time. synchronized(sendr) { // synchronizing the send object sendr.sendMethod(mssg); } } } // Driver class public class ThrowNullExcep2 { // main method public static void main(String args[]) { Sendr sendObj = null; ThreadSend Sth1 = new ThreadSend( ' Hello ' , sendObj ); ThreadSend Sth2 = new ThreadSend( ' Bye Bye ' , sendObj ); // Starting the two threads of the ThreadedSend type Sth1.start(); Sth2.start(); // waiting for the threads to end try { Sth1.join(); Sth2.join(); } catch(Exception exp) { System.out.println('Interrupted : ' + exp); } } } 

Ausgabe:

 Exception in thread 'Thread-0' Exception in thread 'Thread-1' java.lang.NullPointerException: Cannot enter synchronized block because 'this.sendr' is null at ThreadSend.run(ThrowNullExcep2.java:42) java.lang.NullPointerException: Cannot enter synchronized block because 'this.sendr' is null at ThreadSend.run(ThrowNullExcep2.java:42) 

• Anstatt einen Wert auszulösen, wird Null ausgegeben.

Dateiname: ThrowNullExcep3.java

 // Modifying or accessing the fields of the Null object. public class ThrowExcep3 { int a; // main method public static void main(String args[]) { // assigning a null value ThrowExcep3 obj = null; obj.a = 3; } } 

Ausgabe:

 Exception in thread 'main' java.lang.NullPointerException: Cannot assign field 'a' because '' is null at ThrowExcep3.main(ThrowExcep3.java:10) 

Anforderung eines NULL-Werts

Eine Null ist ein spezieller Wert, der in Java verwendet wird. Es wird normalerweise verwendet, um anzuzeigen, dass der Referenzvariablen kein Wert zugewiesen wird. Ein Nullwert wird hauptsächlich bei der Implementierung von Datenstrukturen wie einer verknüpften Liste oder einem Baum verwendet. Es wird auch im Singleton-Muster verwendet.

Vermeidung der NullPointerException

Um die NullPointerException zu vermeiden, sollte man sicherstellen, dass die Initialisierung aller Objekte ordnungsgemäß erfolgt, bevor man sie verwenden kann. Wenn man eine Referenzvariable deklariert, sollte man sicherstellen, dass der Referenz kein Nullwert zugewiesen ist, bevor der Referenzwert für den Zugriff auf das Feld oder die Methode verwendet wird.

Beachten Sie die folgenden häufigen Probleme bei der Lösung.

Fall 1: Vergleich von Strings mit dem Literal

Zu den häufigsten Problemen gehört der Vergleich eines Literals mit einer String-Variablen. Das Literal kann ein Element aus einem Enum oder einem String sein. Anstatt die Methode vom Nullobjekt aus aufzurufen, sollten Sie erwägen, sie mithilfe des Literals aufzurufen.

Dateiname: NullPntrExcption.java

 import java.io.*; public class NullPntrExcption { // main method public static void main (String[] args) { // Initializing a String variable with a null value String pntr = null; // Checking if pntr.equals null or works fine. try { // The following line of code will raise the NullPointerException // It is because the pntr is null if (pntr.equals('JTP')) { System.out.print('String are the same.'); } else { System.out.print('Strinng are not the same.'); } } catch(NullPointerException e) { System.out.print('NullPointerException has been caught.'); } } } 

Ausgabe:

 NullPointerException has been caught. 

Nun wollen wir sehen, wie man es vermeiden kann.

Rohit Shetty-Schauspieler

Dateiname: NullPntrExcption1.java

 public class NullPntrExcption1 { // main method public static void main (String[] args) { // Initializing a String variable with a null value String pntr = null; // Checking if pntr.equals null or works fine. try { // Now, the following line of code will not raise the NullPointerException // It is because the string literal is invoking the equals() method if ('JTP'.equals(pntr)) { System.out.print('String are the same.'); } else { System.out.print('Strinng are not the same.'); } } catch(NullPointerException e) { System.out.print('NullPointerException has been caught.'); } } } 

Ausgabe:

 NullPointerException has been caught. 

Fall 2: Behalten Sie die Methodenargumente im Auge

Man muss zuerst die Methodenargumente auf Nullwerte überprüfen und dann mit der Methodenausführung fortfahren. Andernfalls besteht eine gute Chance, dass eine IllegalArgumentException ausgelöst wird und der aufrufenden Methode außerdem signalisiert wird, dass die übergebenen Argumente falsch sind.

Dateiname: NullPntrExcption2.java

 // A program for demonstrating that one must // check the parameters are null or not before // using them. import java.io.*; public class NullPntrExcption2 { public static void main (String[] args) { // String st is an empty string and invoking method getLength() String st = ''; try { System.out.println(getLength(st)); } catch(IllegalArgumentException exp) { System.out.println('IllegalArgumentException has been caught.'); } // String s set to a value and invoking method getLength() st = 'JTP'; try { System.out.println(getLength(st)); } catch(IllegalArgumentException exp) { System.out.println('IllegalArgumentException has been caught.'); } // Setting st with a value null and invoking method getLength() st = null; try { System.out.println(getLength(st)); } catch(IllegalArgumentException exp) { System.out.println('IllegalArgumentException has been caught. ' + exp); } } // method taht computes the length of a string st. // It throws and IllegalArgumentException, if st is null public static int getLength(String st) { if (st == null) { throw new IllegalArgumentException('The argument can never be null.'); } return st.length(); } } 

Ausgabe:

 0 3 IllegalArgumentException has been caught. java.lang.IllegalArgumentException: The argument can never be null. 

Fall 3: Verwendung eines ternären Operators

Man kann auch den ternären Operator verwenden, um die NullPointerException zu vermeiden. Ternär wird der boolesche Ausdruck zuerst ausgewertet. Wenn der Ausdruck als wahr ausgewertet wird, wird val1 zurückgegeben. Andernfalls wird val2 zurückgegeben.

Dateiname: NullPntrExcption3.java

 // A program for demonstrating the fact that // NullPointerException can be avoided using the ternary operator. import java.io.*; public class NullPntrExcption3 { // main method public static void main (String[] args) { // Initializing String variable with null value String st = null; String mssge = (st == null) ? 'String is Null.' : st.substring(0, 5); System.out.println(mssge); // Initializing the String variable with string literal st = 'javaTpoint'; mssge = (st == null) ? '' : st.substring(0, 10); System.out.println(mssge); } } 

Ausgabe:

 String is Null. javaTpoint