Java >> Java Program >  >> Tag >> java.lang

java.lang.NullPointerException Exempel – Hur man hanterar Java Null Pointer Exception (med video)

I det här inlägget presenterar vi ett omfattande exempel på java.lang.NullPointerException – Java Null Pointer Exception. I Java, en speciell null värde kan tilldelas ett objekts referens och anger att objektet för närvarande pekar på en okänt bit av data. En java.lang.NullPointerException kastas när ett program försöker använda eller komma åt ett objekt vars referens är lika med null . Följande fall ger undantag från Null Pointer:

  • Anropar en metod från en null objekt.
  • Åtkomst till eller ändra en null objektets fält.
  • Med längden null , som om det vore en array.
  • Åtkomst till eller modifiering av platserna för null objekt, som om det vore en array.
  • Slänger null , som om det vore en Throwable värde.
  • När du försöker synkronisera över en null objekt.

java.lang.NullPointerException är en RuntimeException och därmed Javac kompilatorn inte tvinga dig att använda ett försöksfångstblock för att hantera det på rätt sätt.

Du kan också kolla den här handledningen i följande video:

1. Varför behöver vi nollvärdet?

Som redan nämnts, null är ett speciellt värde som används i Java. Det är extremt användbart för att koda vissa designmönster, som Null Object-mönster och Singleton-mönster. Null Object-mönstret tillhandahåller ett objekt som ett surrogat för avsaknaden av ett objekt av en given typ. Singleton-mönstret säkerställer att endast en instans av en klass skapas och syftar också till att tillhandahålla en global åtkomstpunkt till objektet.

Till exempel ett exempel på ett sätt att skapa högst ett instans av en klass är att deklarera alla dess konstruktörer som privata och sedan skapa en offentlig metod som returnerar den unika instansen av klassen:

TestSingleton.java
import java.util.UUID;
 
class Singleton {
 
     private static Singleton single = null;
     private String ID = null;
 
     private Singleton() {
          /* Make it private, in order to prevent the creation of new instances of
           * the Singleton class. */
 
          ID = UUID.randomUUID().toString(); // Create a random ID.
     }
 
     public static Singleton getInstance() {
          if (single == null)
               single = new Singleton();
 
          return single;
     }
 
     public String getID() {
          return this.ID;
     }
}
 
public class TestSingleton {
     public static void main(String[] args) {
          Singleton s = Singleton.getInstance();
          System.out.println(s.getID());
     }
}

I det här exemplet deklarerar vi en statisk instans av Singleton-klassen. Den instansen initieras högst en gång i getInstance metod. Lägg märke till användningen av null värde som möjliggör skapande av unik instans.

2. Hur man undviker java.lang.NullPointerException

För att undvika NullPointerException , se till att alla dina objekt initieras ordentligt innan du använder dem. Lägg märke till att när du deklarerar en referensvariabel skapar du verkligen en pekare till ett objekt. Du måste verifiera att pekaren inte är null innan du begär metoden eller ett fält från objektet.

Om undantaget kastas, använd informationen som finns i undantagets stackspårning. Körningens stackspårning tillhandahålls av JVM, för att möjliggöra felsökning av applikationen. Leta reda på metoden och raden där undantaget fångades och ta reda på vilken referens som är lika med null i den specifika raden.

I resten av det här avsnittet kommer vi att beskriva några tekniker som hanterar ovannämnda undantag. Men de eliminerar inte problemet och programmeraren bör alltid vara försiktig när han kodar en applikation.

2.1 Strängjämförelse med bokstaver

Ett mycket vanligt fall i en applikations exekveringskod involverar jämförelsen mellan en strängvariabel och en literal. Det bokstavliga kan vara en sträng eller elementet i en Enum. Istället för att anropa metoden från null-objektet, överväg att anropa den från det bokstavliga. Observera till exempel följande fall:

String str = null;
if(str.equals("Test")) {
     /* The code here will not be reached, as an exception will be thrown. */
}

Ovanstående kodavsnitt ger en NullPointerException . Men om vi anropar metoden från det bokstavliga, fortsätter exekveringsflödet normalt:

String str = null;
if("Test".equals(str)) {
     /* Correct use case. No exception will be thrown. */
}

2.2 Kontrollera argumenten för en metod

Innan du kör din egen metods brödtext, se till att kontrollera dess argument för nollvärden. Fortsätt med exekveringen av metoden, endast när argumenten är korrekt kontrollerade. Annars kan du skicka en IllegalArgumentException och meddela anropsmetoden att något är fel med de godkända argumenten.

Till exempel:

public static int getLength(String s) {
     if (s == null)
          throw new IllegalArgumentException("The argument cannot be null");
 
     return s.length();
}

2.3 Prefer String.valueOf()-metoden istället för toString()

När din applikations kod kräver strängrepresentation av ett objekt, undvik att använda objektets toString metod. Om ditt objekts referens är lika med null , en NullPointerException kommer att kastas.

Överväg istället att använda den statiska String.valueOf metod, som inte ger några undantag och skriver ut "null" , om funktionens argument är lika med null .

2.4 Använd den ternära operatören

ternary operatör kan vara mycket användbar och kan hjälpa oss att undvika NullPointerException . Operatören har formen:

boolean expression ? value1 : value2;

Först utvärderas det booleska uttrycket. Om uttrycket är sant returneras värde1, annars returneras värde2. Vi kan använda ternary operatör för att hantera nollpekare enligt följande:

String message = (str == null) ? "" : str.substring(0, 10);

Meddelandevariabeln kommer att vara tom om str referensen är null. Annars, om str pekar på faktiska data, kommer meddelandet att hämta de första 10 tecknen i den.

2.5 Skapa metoder som returnerar tomma samlingar istället för null

En mycket bra teknik är att skapa metoder som returnerar en tom samling, istället för en null värde. Din applikations kod kan iterera över den tomma samlingen och använda dess metoder och fält, utan att skicka en NullPointerException . Till exempel:Example.java

public class Example {
     private static List numbers = null;
 
     public static List getList() {
          if (numbers == null)
               return Collections.emptyList();
          else
               return numbers;
     }
}

2.6 Använd Apaches StringUtils-klass

Apaches Commons Lang är ett bibliotek som tillhandahåller hjälpverktyg för java.lang API, som strängmanipulationsmetoder. En exempelklass som tillhandahåller strängmanipulation är StringUtils.java , som hanterar null mata in strängar tyst.

Du kan använda StringUtils.isNotEmpty, StringUtils.IsEmpty och StringUtils.equals metoder, för att undvika NullPointerException . Till exempel:

if (StringUtils.isNotEmpty(str)) {
     System.out.println(str.toString());
}

2.7 Använd metoderna contains(), containsKey(), containsValue()

Om din applikationskod använder samlingar, till exempel Maps , överväg att använda innehåller, containsKey och containsValue metoder. Hämta till exempel värdet på en specifik nyckel efter att du har verifierat dess existens på kartan:

Map map = …
…
String key = …
String value = map.get(key);
System.out.println(value.toString()); // An exception will be thrown, if the value is null.

I kodavsnittet ovan kontrollerar vi inte om nyckeln faktiskt finns i Map och därför kan det returnerade värdet vara null . Det säkraste sättet är följande:

Map map = …
…
String key = …
if(map.containsKey(key)) {
     String value = map.get(key);
     System.out.println(value.toString()); // No exception will be thrown.
}

2.8 Använda try-catch block

Vi kan hantera NullPointerException med hjälp av try-catch-blocket. Låt oss ta ett exempel på att jämföra med två strängars likhet.Hantera null med hjälp av try-catch-blocket

// Initializing String variable with null value
String nullString = null;

// Checking if nullString.equals(any_string) or works fine.
try {
    // This line of code throws NullPointerException
    // because ptr is null
    if (nullString.equals("any_string"))
        System.out.println("Both strings are same.");
    else
        System.out.println("Both strings are same.");
} catch (NullPointerException e) {
    System.out.println("NullPointerException occurred");
}

I exemplet ovan har vi skapat en sträng och tilldelat den nollvärdet. Senare kallade vi equals-metoden på den strängen och den kastade java.lang.NullPointerException som fastnade i catch-blocket. Här är resultatet av ovanstående kodavsnitt.Resultat

NullPointerException occurred

Vi kan undvika ovanstående undantag genom att anropa metoden från bokstaven istället för att anropa den från null-objektet enligt följande:Avoiding null using literal

// Initializing String variable with null value
String nullString = null;

// Checking if "any_string".equals(nullString) or works fine.
try {
    // This line of code throws NullPointerException
    // because ptr is null
    if ("any_string".equals(nullString))
        System.out.println("Both strings are same.");
    else
        System.out.println("Both strings are same.");
} catch (NullPointerException e) {
    System.out.println("NullPointerException occurred");
}

I exemplet ovan, för att undvika ovanstående undantag genom att anropa metoden från den bokstavliga istället för att anropa den från null-objektet. Nedan visas utdata från ovanstående kodavsnitt:Resultat

Both strings are not same.

2.9 Kontrollera returvärdet för externa metoder

Det är mycket vanligt i praktiken att använda externa bibliotek. Dessa bibliotek innehåller metoder som returnerar en referens. Se till att den returnerade referensen inte är null . Överväg också att läsa Javadoc för metoden för att bättre förstå dess funktionalitet och dess returvärden.

2.10 Användningspåståenden

Påståenden är mycket användbara när du testar din kod och kan användas för att undvika exekvering av kodavsnitt som ger en NullPointerException . Java Assertions implementeras med nyckelordet assert och ger en AssertionError .

Observera att du uttryckligen måste aktivera påståendeflaggan för JVM, genom att köra den med –ea argument. Annars kommer påståendena att ignoreras helt.

Ett exempel på Java-påståenden är följande:

public static int getLength(String s) {
     /* Ensure that the String is not null. */
     assert (s != null);
 
     return s.length();
}

Om du kör ovanstående kodavsnitt och skickar ett null-argument till getLength , kommer följande felmeddelande att visas:

Exception in thread "main" java.lang.AssertionError

Slutligen kan du använda Assert klass som tillhandahålls av jUnit ramverk för testning.

2.11 enhetstester

Enhetstester kan vara extremt användbara när du testar din kods funktionalitet och korrekthet. Ägna lite tid åt att skriva ett par testfall som verifierar att ingen NullPointerException kastas, medan din applikations kod genomgår ett specifikt exekveringsflöde.

3. Befintliga NullPointerException säkra metoder

3.1 Få åtkomst till statiska medlemmar eller metoder för en klass

När din kod försöker komma åt en statisk variabel eller metod för en klass, även om objektets referens är lika med null , skickar JVM inte en NullPointerException . Detta beror på det faktum att Java-kompilatorn lagrar de statiska metoderna och fälten på en speciell plats under kompileringsproceduren. De statiska fälten och metoderna är alltså inte associerade med objekt, snarare med namnet på klassen.

Till exempel skickar följande kod inte en NullPointerException :TestStatic.java:

class SampleClass {
 
     public static void printMessage() {
          System.out.println("Hello from Java Code Geeks!");
     }
}
 
public class TestStatic {
     public static void main(String[] args) {
          SampleClass sc = null;
          sc.printMessage();
     }
}

Observera att trots det faktum att instansen av SampleClass är lika med null , kommer metoden att köras korrekt. Men när det kommer till statiska metoder eller fält är det bättre att komma åt dem på ett statiskt sätt, såsom SampleClass.printMessage() .

3.2 Instanceof operator

instanceof operatorn kan användas, även om objektets referens är lika med null . instanceof operatorn returnerar false när referensen är lika med null och inte kastar en NullPointerException . Tänk till exempel på följande kodavsnitt:

String str = null;
if(str instanceof String)
     System.out.println("It's an instance of the String class!");
else
     System.out.println("Not an instance of the String class!");

Resultatet av exekveringen är, som förväntat:

Not an instance of the String class!

Det här var en handledning om hur man hanterar Java Null Pointer Exception ( java.lang.NullPointerException – NullPointerException )

  • Testa Catch Java-exempel
  • Javahandledning för nybörjare
  • Vad används Java till

Den här källan innehåller exempelkodavsnitten som används i den här artikeln för att illustrera java.lang.NullPointerException Exempel – Hur man hanterar Java Null Pointer Exception.Apache Commons Lang presenterade Null Object Pattern Singleton Pattern

Java-tagg