Wat zijn Null Pointer Exceptions (java.lang.NullPointerException) en waardoor worden ze veroorzaakt?

Welke methoden/tools kunnen worden gebruikt om de oorzaak te achterhalen, zodat u voorkomt dat de uitzondering ervoor zorgt dat het programma voortijdig wordt beëindigd?

---

Antwoord 1, autoriteit 100%

Wanneer u een referentievariabele declareert (d.w.z. een object), maakt u in feite een aanwijzer naar een object. Beschouw de volgende code waar je een variabele van het primitieve type int declareert:

int x;
x = 10;

In dit voorbeeld is de variabele x een int en Java initialiseert deze voor u naar 0. Wanneer u de waarde van 10 op de tweede regel toewijst, wordt uw waarde van 10 geschreven naar de geheugenlocatie waarnaar wordt verwezen door x.

Maar wanneer u een referentie type probeert te declareren, gebeurt er iets anders. Neem de volgende code:

Integer num;
num = new Integer(10);

De eerste regel declareert een variabele met de naam num, maar bevat nog geen primitieve waarde. In plaats daarvan bevat het een aanwijzer (omdat het type Integer is, wat een referentietype is). Omdat je nog niet hebt gezegd waarnaar je moet verwijzen, stelt Java het in op null, wat betekent “Ik wijs naar niets“.

In de tweede regel wordt het trefwoord new gebruikt om een ​​object van het type Integer te instantiëren (of te creëren), en de pointervariabele num is toegewezen aan dat Integer-object.

De NullPointerException (NPE) treedt op wanneer u een variabele declareert maar geen object hebt gemaakt en dit aan de variabele toewijst voordat u de inhoud van de variabele probeert te gebruiken (genaamd dereferentie em>). Je verwijst dus naar iets dat niet echt bestaat.

Dereferentie gebeurt meestal wanneer . wordt gebruikt om toegang te krijgen tot een methode of veld, of wanneer [] wordt gebruikt om een ​​array te indexeren.

Als u probeert om num voordat het object te maken, probeert te dereferentie krijgt u een NullPointerException. In de meest triviale gevallen zal de compiler het probleem opvangen en u laten weten dat “num may not have been initialized“, maar soms kunt u code schrijven die het object niet rechtstreeks maakt.

U heeft bijvoorbeeld een methode als volgt:

public void doSomething(SomeObject obj) {
   // Do something to obj, assumes obj is not null
   obj.myMethod();
}

In dat geval maakt u niet het object obj, maar neemt u aan dat het is gemaakt voordat de methode doSomething() werd aangeroepen. Let op, het is mogelijk om de methode als volgt aan te roepen:

doSomething(null);

In dat geval is obj null en zal de instructie obj.myMethod() een NullPointerException.

Als de methode bedoeld is om iets met het doorgegeven object te doen zoals de bovenstaande methode doet, is het gepast om de NullPointerException te gooien omdat het een programmeerfout is en de programmeur die informatie nodig heeft voor foutopsporingsdoeleinden.

Naast NullPointerExceptions die worden gegenereerd als gevolg van de logica van de methode, kunt u ook de methodeargumenten voor null-waarden controleren en NPE’s expliciet genereren door iets toe te voegen als de volgende aan het begin van een methode:

// Throws an NPE with a custom error message if obj is null
Objects.requireNonNull(obj, "obj must not be null");

Houd er rekening mee dat het handig is om in uw foutmelding duidelijk te vermelden welk object niet null mag zijn. Het voordeel van het valideren hiervan is dat 1) u uw eigen duidelijkere foutmeldingen kunt retourneren en 2) voor de rest van de methode weet u dat tenzij obj opnieuw wordt toegewezen, deze niet null is en veilig kan worden verwijderd .

Als alternatief kunnen er gevallen zijn waarin het doel van de methode niet alleen is om op het doorgegeven object te werken, en daarom kan een null-parameter acceptabel zijn. In dit geval moet u controleren op een null-parameter en u anders gedragen. U moet dit ook uitleggen in de documentatie. doSomething() kan bijvoorbeeld worden geschreven als:

/**
  * @param obj An optional foo for ____. May be null, in which case
  *  the result will be ____.
  */
public void doSomething(SomeObject obj) {
    if(obj == null) {
       // Do something
    } else {
       // Do something else
    }
}

Ten slotte, Hoe de uitzondering te lokaliseren & veroorzaken met behulp van Stack Trace

Welke methoden/tools kunnen worden gebruikt om de oorzaak vast te stellen zodat u stopt?
de uitzondering dat het programma voortijdig wordt beëindigd?

Sonar met zoekbugs kan NPE detecteren.
Kan met sonar nullpointer-uitzonderingen die door JVM dynamisch worden veroorzaakt, worden opgevangen

Nu heeft Java 14 een nieuwe taalfunctie toegevoegd om de hoofdoorzaak van NullPointerException aan te tonen. Deze taalfunctie maakt sinds 2006 deel uit van SAP commerciële JVM.

In Java 14 is het volgende een voorbeeld van een NullPointerException Exception-bericht:

in thread “main” java.lang.NullPointerException: kan “java.util.List.size()” niet aanroepen omdat “list” null is

---

Antwoord 2, autoriteit 23%

NullPointerExceptions zijn uitzonderingen die optreden wanneer u een verwijzing probeert te gebruiken die naar geen enkele locatie in het geheugen verwijst (null) alsof het naar een object verwijst. Het aanroepen van een methode op een null-referentie of het proberen toegang te krijgen tot een veld van een null-referentie zal een NullPointerException activeren. Dit zijn de meest voorkomende, maar andere manieren staan ​​vermeld op de NullPointerException javadoc-pagina.

Waarschijnlijk de snelste voorbeeldcode die ik kon bedenken om een ​​NullPointerException te illustreren, zou zijn:

public class Example {
    public static void main(String[] args) {
        Object obj = null;
        obj.hashCode();
    }
}

Op de eerste regel binnen main stel ik expliciet de Object-referentie obj gelijk aan null . Dit betekent dat ik een referentie heb, maar deze verwijst niet naar een object. Daarna probeer ik de referentie te behandelen alsof deze naar een object verwijst door er een methode op aan te roepen. Dit resulteert in een NullPointerException omdat er geen code is om uit te voeren op de locatie waarnaar de verwijzing verwijst.

(Dit is een technisch detail, maar ik denk dat het vermelden waard is: een verwijzing die naar null verwijst, is niet hetzelfde als een C-aanwijzer die verwijst naar een ongeldige geheugenlocatie. Een null-aanwijzer wijst letterlijk nergens naar toe , wat subtiel anders is dan verwijzen naar een locatie die toevallig ongeldig is.)

---

Antwoord 3, autoriteit 18%

Wat is een NullPointerException?

Een goede plek om te beginnen is de JavaDocs. Ze hebben dit gedekt:

Gegooid wanneer een toepassing null probeert te gebruiken in een geval waarin een
voorwerp is vereist. Deze omvatten:

• De instantiemethode van een null-object aanroepen.
• Het veld van een null-object openen of wijzigen.
• De lengte van null nemen alsof het een array is.
• De slots van null openen of wijzigen alsof het een array is.
• Null gooien alsof het een Throwable-waarde is.

Applicaties zouden instanties van deze klasse moeten genereren om andere aan te geven
illegaal gebruik van het null-object.

Het is ook zo dat als je een null-referentie probeert te gebruiken met synchronized, dat ook deze uitzondering veroorzaakt, volgens de JLS:

SynchronizedStatement:
    synchronized ( Expression ) Block

• Anders, als de waarde van de expressie null is, wordt er een NullPointerException gegenereerd.

Hoe los ik het op?

Dus je hebt een NullPointerException. Hoe repareer je het? Laten we een eenvoudig voorbeeld nemen dat een NullPointerException genereert:

public class Printer {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public void print() {
        printString(name);
    }
    private void printString(String s) {
        System.out.println(s + " (" + s.length() + ")");
    }
    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print();
    }
}

Identificeer de null-waarden

De eerste stap is het exact identificeren welke waarden de uitzondering veroorzaken. Hiervoor moeten we wat debuggen. Het is belangrijk om een ​​stacktrace te leren lezen. Dit laat je zien waar de uitzondering is gegenereerd:

Exception in thread "main" java.lang.NullPointerException
    at Printer.printString(Printer.java:13)
    at Printer.print(Printer.java:9)
    at Printer.main(Printer.java:19)

Hier zien we dat de uitzondering wordt gegenereerd op regel 13 (in de printString-methode). Kijk naar de regel en controleer welke waarden null zijn door
het toevoegen van loginstructies of het gebruik van een debugger. We komen erachter dat s null is, en het aanroepen van de length methode daarop genereert de uitzondering. We kunnen zien dat het programma stopt met het genereren van de uitzondering wanneer s.length() uit de methode wordt verwijderd.

Traceer waar deze waarden vandaan komen

Controleer vervolgens waar deze waarde vandaan komt. Door de aanroepers van de methode te volgen, zien we dat s wordt doorgegeven met printString(name) in de print() methode, en this.name is null.

Traceer waar deze waarden moeten worden ingesteld

Waar is this.name ingesteld? In de setName(String) methode. Met wat meer foutopsporing kunnen we zien dat deze methode helemaal niet wordt aangeroepen. Als de methode is aangeroepen, controleer dan de volgorde waarin deze methoden worden aangeroepen, en de ingestelde methode wordt niet na de afdrukmethode genoemd.

Dit is voldoende om ons een oplossing te bieden: voeg een aanroep toe aan printer.setName() voordat u printer.print() aanroept.

Andere oplossingen

De variabele kan een standaardwaarde hebben (en setName kan voorkomen dat deze op null wordt gezet):

private String name = "";

De methode print of printString kan controleren op null, bijvoorbeeld:

printString((name == null) ? "" : name);

Of je kunt de klasse zo ontwerpen dat name altijd een niet-null-waarde heeft:

public class Printer {
    private final String name;
    public Printer(String name) {
        this.name = Objects.requireNonNull(name);
    }
    public void print() {
        printString(name);
    }
    private void printString(String s) {
        System.out.println(s + " (" + s.length() + ")");
    }
    public static void main(String[] args) {
        Printer printer = new Printer("123");
        printer.print();
    }
}

Zie ook:

• Het vermijden van != null -statements in Java?

Ik kan het probleem nog steeds niet vinden

Als je hebt geprobeerd het probleem op te lossen en nog steeds geen oplossing hebt, kun je een vraag stellen voor meer hulp, maar zorg ervoor dat je opneemt wat je tot nu toe hebt geprobeerd. neem minimaal de stacktrace op in de vraag, en markeer de belangrijke regelnummers in de code. Probeer ook eerst de code te vereenvoudigen (zie SSCCE).

---

Antwoord 4, autoriteit 13%

Vraag: wat veroorzaakt een NullPointerException (NPE)?

Zoals u zou moeten weten, zijn Java-typen onderverdeeld in primitieve typen (boolean, int, enz.) en referentietypen . Met referentietypen in Java kunt u de speciale waarde null gebruiken, wat de Java-manier is om “geen object” te zeggen.

Een NullPointerException wordt tijdens runtime gegenereerd wanneer uw programma een null probeert te gebruiken alsof het een echte referentie is. Als u bijvoorbeeld dit schrijft:

public class Test {
    public static void main(String[] args) {
        String foo = null;
        int length = foo.length();   // HERE
    }
}

de instructie met het label “HERE” gaat proberen de methode length() uit te voeren op een null-referentie, en dit zal een NullPointerException.

Er zijn veel manieren waarop u een null-waarde kunt gebruiken die resulteert in een NullPointerException. In feite zijn de enige dingen die u kunt met een null zonder een NPE te veroorzaken:

• wijs het toe aan een referentievariabele of lees het uit een referentievariabele,
• wijs het toe aan een array-element of lees het van een array-element (op voorwaarde dat de array-verwijzing zelf niet-null is!),
• geef het door als parameter of retourneer het als resultaat, of
• test het met de operators == of !=, of instanceof.

Vraag: Hoe lees ik de NPE-stacktrace?

Stel dat ik het bovenstaande programma compileer en uitvoer:

$ javac Test.java 
$ java Test
Exception in thread "main" java.lang.NullPointerException
    at Test.main(Test.java:4)
$

Eerste observatie: de compilatie slaagt! Het probleem in het programma is GEEN compilatiefout. Het is een runtime-fout. (Sommige IDE’s kunnen waarschuwen dat uw programma altijd een uitzondering zal genereren … maar de standaard javac-compiler doet dat niet.)

Tweede observatie: wanneer ik het programma start, geeft het twee regels “gobbledy-gook” weer. VERKEERD!! Dat is niet flauwekul. Het is een stacktrace … en het biedt essentiële informatie waarmee u de fout in uw code kunt opsporen als u de tijd neemt om deze aandachtig te lezen.

Dus laten we eens kijken naar wat er staat:

Exception in thread "main" java.lang.NullPointerException

De eerste regel van de stacktracering vertelt je een aantal dingen:

• Het vertelt je de naam van de Java-thread waarin de uitzondering is gegenereerd. Voor een eenvoudig programma met één thread (zoals deze) zal het “main” zijn. Laten we verder gaan …
• Het vertelt je de volledige naam van de uitzondering die is gegenereerd; bijv. java.lang.NullPointerException.
• Als de uitzondering een bijbehorend foutbericht heeft, wordt dat na de naam van de uitzondering uitgevoerd. NullPointerException is in dit opzicht ongebruikelijk, omdat het zelden een foutmelding bevat.

De tweede regel is de belangrijkste bij het diagnosticeren van een NPE.

at Test.main(Test.java:4)

Dit vertelt ons een aantal dingen:

• “at Test.main” zegt dat we in de main-methode van de klasse test zaten.
• “Test.java:4” geeft de bronbestandsnaam van de klasse, EN het vertelt ons dat de instructie waar dit gebeurde in regel 4 van het bestand staat.

Als je de regels in het bovenstaande bestand meetelt, is regel 4 degene die ik heb gelabeld met de opmerking “HIER”.

Houd er rekening mee dat er in een ingewikkelder voorbeeld veel regels in de NPE-stacktracering zullen zijn. Maar u kunt er zeker van zijn dat de tweede regel (de eerste “at”-regel) u zal vertellen waar de NPE is gegooid¹.

Kortom, de stacktracering zal ons ondubbelzinnig vertellen welk statement van het programma de NPE heeft veroorzaakt.

Zie ook: Wat is een stacktracering en hoe kan ik deze gebruiken om fouten in mijn toepassing op te sporen?

^{1 – Niet helemaal waar. Er zijn dingen die geneste uitzonderingen worden genoemd…}

Vraag: Hoe vind ik de oorzaak van de NPE-uitzondering in mijn code?

Dit is het moeilijkste. Het korte antwoord is om logische gevolgtrekkingen toe te passen op het bewijs geleverd door de stacktracering, de broncode en de relevante API-documentatie.

Laten we het eerst illustreren met het eenvoudige voorbeeld (hierboven). We beginnen met te kijken naar de regel die de stacktracering ons heeft verteld waar de NPE plaatsvond:

int length = foo.length(); // HERE

Hoe kan dat een NPE opleveren?

In feite is er maar één manier: het kan alleen gebeuren als foo de waarde null heeft. We proberen dan de length() methode uit te voeren op null en… BANG!

Maar (hoor ik u zeggen) wat als de NPE binnen de length()-methodeaanroep werd gegooid?

Nou, als dat zou gebeuren, zou de stacktracering er anders uitzien. De eerste “at”-regel zou zeggen dat de uitzondering in een regel in de klasse java.lang.String is gegenereerd en regel 4 van Test.java zou de tweede zijn ” op” regel.

Dus waar komt die null vandaan? In dit geval is het duidelijk, en het is duidelijk wat we moeten doen om het te repareren. (Wijs een niet-null-waarde toe aan foo.)

Ok, laten we een iets lastiger voorbeeld proberen. Dit vereist enige logische deductie.

public class Test {
    private static String[] foo = new String[2];
    private static int test(String[] bar, int pos) {
        return bar[pos].length();
    }
    public static void main(String[] args) {
        int length = test(foo, 1);
    }
}
$ javac Test.java 
$ java Test
Exception in thread "main" java.lang.NullPointerException
    at Test.test(Test.java:6)
    at Test.main(Test.java:10)
$ 

Dus nu hebben we twee “at”-regels. De eerste is voor deze regel:

return args[pos].length();

en de tweede is voor deze regel:

int length = test(foo, 1);

Kijkend naar de eerste regel, hoe kan dat een NPE opleveren? Er zijn twee manieren:

• Als de waarde van bar null is, dan zal bar[pos] een NPE genereren.
• Als de waarde van bar[pos] null is, dan zal het aanroepen van length() een NPE opleveren.

Vervolgens moeten we uitzoeken welke van die scenario’s verklaart wat er werkelijk gebeurt. We beginnen met het verkennen van de eerste:

Waar komt bar vandaan? Het is een parameter voor de test methodeaanroep, en als we kijken naar hoe test werd aangeroepen, kunnen we zien dat het afkomstig is van de foo statische variabele. Bovendien kunnen we duidelijk zien dat we foo hebben geïnitialiseerd op een niet-null-waarde. Dat is voldoende om deze uitleg voorlopig van de hand te wijzen. (In theorie zou iets anders veranderen foo in null … maar dat gebeurt hier niet.)

En hoe zit het met ons tweede scenario? Welnu, we kunnen zien dat pos 1 is, dus dat betekent dat foo[1] null moet zijn. Is dit mogelijk?

Inderdaad! En dat is het probleem. Als we zo initialiseren:

private static String[] foo = new String[2];

we wijzen een String[] toe met twee elementen die zijn geïnitialiseerd op null. Daarna hebben we de inhoud van foo niet gewijzigd … dus foo[1] is nog steeds null.

Hoe zit het met Android?

Op Android is het iets eenvoudiger om de directe oorzaak van een NPE op te sporen. Het uitzonderingsbericht vertelt u meestal het (compileertijd) type van de null-referentie die u gebruikt en de methode die u probeerde aan te roepen toen de NPE werd gegenereerd. Dit vereenvoudigt het proces van het lokaliseren van de directe oorzaak.

Maar aan de andere kant heeft Android een aantal veelvoorkomende platformspecifieke oorzaken voor NPE’s. Een veelvoorkomend probleem is wanneer getViewById onverwachts een null retourneert. Mijn advies zou zijn om te zoeken naar Q&A’s over de oorzaak van de onverwachte null-retourwaarde.

---

Antwoord 5, autoriteit 11%

Het is alsof u toegang probeert te krijgen tot een object dat null is. Beschouw het onderstaande voorbeeld:

TypeA objA;

Op dit moment heeft u dit object net gedeclareerd, maar niet geïnitialiseerd of geïnstantieerd. En wanneer u probeert toegang te krijgen tot een eigenschap of methode erin, wordt NullPointerException gegenereerd, wat logisch is.

Zie ook dit onderstaande voorbeeld:

String a = null;
System.out.println(a.toString()); // NullPointerException will be thrown

---

Antwoord 6, autoriteit 9%

Er wordt een null-aanwijzeruitzondering gegenereerd wanneer een toepassing probeert null te gebruiken in een geval waarin een object vereist is. Deze omvatten:

1. De instantiemethode van een null-object aanroepen.
2. Het veld van een null-object openen of wijzigen.
3. De lengte van null nemen alsof het een array is.
4. Toegang tot of wijziging van de slots van null alsof het een array is.
5. null gooien alsof het een Throwable-waarde is.

Applicaties zouden instanties van deze klasse moeten genereren om ander illegaal gebruik van het null-object aan te geven.

Referentie: http://docs.oracle. com/javase/8/docs/api/java/lang/NullPointerException.html

---

Antwoord 7, autoriteit 9%

Een null-aanwijzer is er een die nergens naar verwijst. Wanneer u de verwijzing naar een pointer p afwijst, zegt u “geef me de gegevens op de locatie die is opgeslagen in “p”. Wanneer p een null-pointer is , de locatie die is opgeslagen in p is nowhere, je zegt “geef me de gegevens op de locatie ‘nergens'”. Uiteraard kan dit niet, dus het genereert een null pointer exception.

Over het algemeen is dit omdat iets niet goed is geïnitialiseerd.

---

Antwoord 8, autoriteit 8%

Er is al veel uitleg aanwezig om uit te leggen hoe het gebeurt en hoe je het kunt oplossen, maar je moet ook best practices volgen om NullPointerExceptions helemaal niet.

Zie ook:
Een goede lijst van best practices

Ik zou willen toevoegen, heel belangrijk, goed gebruik te maken van de final modifier.
Gebruik van de “final” modifier indien van toepassing in Java

Samenvatting:

1. Gebruik de final modifier om een ​​goede initialisatie af te dwingen.
2. Vermijd het retourneren van null in methoden, bijvoorbeeld het retourneren van lege verzamelingen indien van toepassing.
3. Gebruik annotaties @NotNull en @Nullable
4. Faal snel en gebruik asserts om verspreiding van null-objecten door de hele applicatie te voorkomen terwijl ze niet null zouden moeten zijn.
5. Gebruik eerst is gelijk aan een bekend object: if("knownObject".equals(unknownObject)
6. Geef de voorkeur aan valueOf() boven toString().
7. Gebruik null safe StringUtils-methoden StringUtils.isEmpty(null).
8. Gebruik Java 8 Optioneel als retourwaarde in methoden. Optionele klasse biedt een oplossing voor het weergeven van optionele waarden in plaats van null-referenties.

---

Antwoord 9, autoriteit 8%

Een null pointer-uitzondering is een indicator dat u een object gebruikt zonder het te initialiseren.

Hieronder staat bijvoorbeeld een studentenklas die deze in onze code zal gebruiken.

public class Student {
    private int id;
    public int getId() {
        return this.id;
    }
    public setId(int newId) {
        this.id = newId;
    }
}

De onderstaande code geeft je een null pointer-uitzondering.

public class School {
    Student student;
    public School() {
        try {
            student.getId();
        }
        catch(Exception e) {
            System.out.println("Null pointer exception");
        }
    }
}

Omdat je student gebruikt, maar je bent vergeten het te initialiseren zoals in de
juiste code hieronder weergegeven:

public class School {
    Student student;
    public School() {
        try {
            student = new Student();
            student.setId(12);
            student.getId();
        }
        catch(Exception e) {
            System.out.println("Null pointer exception");
        }
    }
}

---

Antwoord 10, autoriteit 8%

In Java heeft alles (behalve primitieve typen) de vorm van een klasse.

Als je een object wilt gebruiken, heb je twee fasen:

1. Verklaren
2. Initialisatie

Voorbeeld:

• Verklaring: Object object;
• Initialisatie: object = new Object();

Hetzelfde geldt voor het array-concept:

• Verklaring: Item item[] = new Item[5];
• Initialisatie: item[0] = new Item();

Als u de initialisatiesectie niet geeft, ontstaat de NullPointerException.

---

Antwoord 11, autoriteit 8%

In Java zijn alle variabelen die u declareert eigenlijk “verwijzingen” naar de objecten (of primitieven) en niet de objecten zelf.

Als je een objectmethode probeert uit te voeren, vraagt ​​de referentie het levende object om die methode uit te voeren. Maar als de referentie verwijst naar NULL (nothing, zero, void, nada), dan kan de methode op geen enkele manier worden uitgevoerd. Dan laat de runtime je dit weten door een NullPointerException te gooien.

Uw referentie “wijst” naar null, dus “Null -> Pointer”.

Het object bevindt zich in de geheugenruimte van de VM en de enige manier om er toegang toe te krijgen is door this-verwijzingen te gebruiken. Neem dit voorbeeld:

public class Some {
    private int id;
    public int getId(){
        return this.id;
    }
    public setId( int newId ) {
        this.id = newId;
    }
}

En op een andere plaats in je code:

Some reference = new Some();    // Point to a new object of type Some()
Some otherReference = null;     // Initiallly this points to NULL
reference.setId( 1 );           // Execute setId method, now private var id is 1
System.out.println( reference.getId() ); // Prints 1 to the console
otherReference = reference      // Now they both point to the only object.
reference = null;               // "reference" now point to null.
// But "otherReference" still point to the "real" object so this print 1 too...
System.out.println( otherReference.getId() );
// Guess what will happen
System.out.println( reference.getId() ); // :S Throws NullPointerException because "reference" is pointing to NULL remember...

Dit is belangrijk om te weten – wanneer er geen verwijzingen meer naar een object zijn (in het bovenstaande voorbeeld wanneer reference en otherReference beide naar null wijzen), dan is het object is onbereikbaar”. We kunnen er op geen enkele manier mee werken, dus dit object is klaar om te worden verzameld en op een gegeven moment zal de VM het geheugen vrijmaken dat door dit object wordt gebruikt en een ander toewijzen.

---

Antwoord 12, autoriteit 7%

Een ander exemplaar van een NullPointerException treedt op wanneer men een objectarray declareert en vervolgens onmiddellijk probeert de verwijzingen naar elementen erin te verwijderen.

String[] phrases = new String[10];
String keyPhrase = "Bird";
for(String phrase : phrases) {
    System.out.println(phrase.equals(keyPhrase));
}

^{Deze specifieke NPE kan worden vermeden als de vergelijkingsvolgorde wordt omgekeerd; gebruik namelijk .equals op een gegarandeerd niet-null object.}

Alle elementen in een array worden geïnitialiseerd naar hun gemeenschappelijke beginwaarde; voor elk type objectarray betekent dit dat alle elementen null zijn.

U moet de elementen in de array initialiseren voordat ze toegankelijk zijn of dereferentie verwijderen.

String[] phrases = new String[] {"The bird", "A bird", "My bird", "Bird"};
String keyPhrase = "Bird";
for(String phrase : phrases) {
    System.out.println(phrase.equals(keyPhrase));
}