Ett NullPointerException i Java är ett RuntimeException. Det inträffar när ett program försöker använda en objektreferens som har nollvärdet. I Java är 'null' ett speciellt värde som kan tilldelas objektreferenser för att indikera frånvaron av ett värde.

Orsaker till undantag för Null Pointer

Ett NullPointerException uppstår av följande skäl: 

• Anropa en metod från ett null-objekt.
• Åtkomst till eller modifiering av ett null-objekts fält.
• Ta längden på noll som om det vore en array.
• Åtkomst till eller modifiering av platserna för null-objekt som om det vore en array.
• Kasta null som om det vore ett kastvärde.
• När du försöker synkronisera över ett null-objekt.

Exempel:

javatable

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

Produktion:

Hangup (SIGHUP)  
Exception in thread 'main' java.lang.NullPointerException  
 at Geeks.main(Geeks.java:10)

Förklaring: I det här exemplet är strängreferensen 's' null. När programmet försöker anropa metoden length() kastar det ett NullPointerException eftersom det inte finns något faktiskt objekt.

java sträng till array

Varför används null i Java?

Nullvärdet fungerar som en platshållare och det indikerar att inget värde är tilldelat en referensvariabel. Vanliga applikationer inkluderar:

• Länkade datastrukturer : Det representerar slutet av en lista eller trädgren.
• Designmönster : Detta används i mönster som Null Object Pattern eller Singleton Pattern.

Hur man undviker NullPointerException

För att undvika NullPointerException måste vi se till att alla objekt initieras ordentligt innan vi använder dem. När vi deklarerar en referensvariabel måste vi verifiera att objektet inte är null innan vi begär en metod eller ett fält från objekten.

1. Använd strängbokstavar i equals()

Ett mycket vanligt kasusproblem involverar jämförelsen mellan en strängvariabel och en bokstavlig. Det bokstavliga kan vara en sträng eller ett element i en Enum. Istället för att anropa metoden från null-objektet, överväg att anropa den från det bokstavliga. 

Exempel:

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

Vi kan undvika NullPointerException genom att anropa lika på literal snarare än objekt.

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

Notera : Anropa alltid lika på bokstaven för att undvika att anropa en metod på en nollreferens.

2. Kontrollera metodargument

Innan vi kör kroppen av den nya metoden bör vi först kontrollera dess argument för nollvärden och fortsätta med exekvering av metoden endast när argumenten är korrekt kontrollerade. Annars kommer det att kasta ett IllegalArgumentException och meddela anropsmetoden att något är fel med de godkända argumenten. 

relationssammansättning

Exempel:

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. Använd ternär operatör

Den ternära operatorn kan användas för att undvika NullPointerException. Först utvärderas det booleska uttrycket. Om uttrycket är sant returneras värde1 annars returneras värde2. Vi kan använda den ternära operatorn för att hantera nollpekare.

Exempel:

gimp tar bort bakgrund

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 

Förklaring : Den ternära operatorn hjälper till att kontrollera noll och undvika operationer på nollreferenser.

4. Använda valfri klass (Java 8+)

I Java 8 introducerades Optional class som ett containerobjekt som kan innehålla ett icke-nullvärde eller inte. Det hjälper till att undvika NullPointerException genom att tvinga att uttryckligen hantera fallet när ett värde saknas.

Exempel:

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 

Förklaring: Optional.ofNullable(value) radbryter värdet som kan vara null. orElse() ger en reserv om värdet inte finns.