Nul

Om te begrijpen wat null betekent in Java, kijken we naar een analogie met getallen: het getal 0 symboliseert de afwezigheid van iets, en null betekent hetzelfde als het gaat om referentiegegevenstypen. Als aan een veld van een referentietype (zoals String , Object of StringBuilder ) niet expliciet een waarde wordt toegewezen, krijgt het, naar analogie met primitieve typen, een standaardwaarde en die waarde is null :

public class Solution {

    public static int i;
    public static String s;

    public static void main(String[] args) {
        System.out.println(i);
        System.out.println(s);
    }
}
                    

Maar als je een array als volgt declareert:

String[] strings = new String[12];

er wordt een array gemaakt met 12 elementen en ze zijn allemaal null :

public class Solution {
    public static void main(String[] args) {
        String[] strings = new String[12];

        for (int i = 0; i < strings.length; i++) {
            System.out.println("Element " + i + ":" + strings[i]);
        }
    }
}
                    

Zoals u kunt zien, wordt de waarde null, wanneer deze wordt samengevoegd met een tekenreeks, de tekenreeks " null ". Dat gezegd hebbende, als je de methode toString() erop aanroept, zoals deze:

String[] strings = null;
System.out.println(strings.toString());

dan krijg je een NullPointerException (we zullen uitzonderingen later in detail bespreken). Hetzelfde gebeurt als u een andere methode op null probeert aan te roepen (de uitzondering zijn statische methoden, die u binnenkort zult leren kennen):

public static void main(String[] args) {
    StringBuilder sb = null;
    sb.append("test"); // This will compile, but there will be a runtime error
}

null is onder andere een gereserveerd sleutelwoord (zoals public of static ), dus u kunt geen variabele, methode of klasse met de naam null maken . Net als de andere is dit sleutelwoord hoofdlettergevoelig (je hebt misschien gemerkt dat we null overal in kleine letters schrijven). Dat betekent:

String firstName = Null; // Compilation error

String secondName = NULL; // Compilation error

String fullName = null; // This will compile

Laten we eens kijken naar wat je nog meer wel en niet kunt doen met null :

• U kunt null toewijzen aan elke referentie:

  
  StringBuilder sb = null;
              

• null kan naar elk referentietype worden gecast:

  
  String s = (String) null; // This will compile, but doing this doesn't make any sense :)
              

• null kan niet worden toegewezen aan een primitieve variabele:

  
  int i = null; // This won't compile
              

• null kan worden vergeleken met == en !=

• null == null retourneert waar

In vorige lessen hebben we besproken dat alles in Java een object is en dat elk object een type heeft.

Wat kunnen we in dit opzicht over null zeggen? null is een letterlijke waarde van een bepaald type en dit type heeft geen naam. En aangezien dit type geen naam heeft, is het onmogelijk om een ​​variabele van dit type te declareren of ernaar te casten. Null is dus de enige vertegenwoordiger van dit naamloze type. In de praktijk kunnen we dit type negeren en null beschouwen als een speciale letterlijke waarde die aan elke referentievariabele kan worden toegewezen.

Dingen om te onthouden:

• null is de standaardwaarde voor referentiegegevenstypen
• null betekent "geen waarde"
• Als we een methode aanroepen op een object waarvan de waarde null is , wordt de code gecompileerd, maar tijdens runtime krijgen we een NullPointerException .