Nul

Pour comprendre ce que null signifie en Java, examinons une analogie avec les nombres : le nombre 0 symbolise l'absence de quelque chose, et null signifie la même chose lorsqu'il s'agit de types de données de référence. Si un champ d'un type référence (tel que String , Object ou StringBuilder ) ne se voit pas explicitement attribuer une valeur, alors, par analogie avec les types primitifs, il reçoit une valeur par défaut, et cette valeur est 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);
    }
}
                    

Mais si vous déclarez un tableau comme celui-ci :

String[] strings = new String[12];

un tableau sera créé contenant 12 éléments, et tous seront nuls :

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]);
        }
    }
}
                    

Comme vous pouvez le voir, lorsqu'elle est concaténée avec une chaîne, la valeur null devient la chaîne " null ". Cela dit, si vous appelez la méthode toString() dessus, comme ceci :

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

alors vous obtiendrez une NullPointerException (nous discuterons des exceptions en détail plus tard). La même chose se produit si vous essayez d'appeler une autre méthode sur null (à l'exception des méthodes statiques, que vous apprendrez bientôt) :

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

null est, entre autres, un mot-clé réservé (comme public ou static ), vous ne pouvez donc pas créer une variable, une méthode ou une classe nommée null . Comme les autres, ce mot-clé est sensible à la casse (vous avez peut-être remarqué que nous écrivons null en minuscule partout). Cela signifie:

String firstName = Null; // Compilation error

String secondName = NULL; // Compilation error

String fullName = null; // This will compile

Regardons ce que vous pouvez et ne pouvez pas faire d'autre avec null :

• Vous pouvez attribuer null à n'importe quelle référence :

  
  StringBuilder sb = null;
              

• null peut être converti en n'importe quel type de référence :

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

• null ne peut pas être affecté à une variable primitive :

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

• null peut être comparé en utilisant == et !=

• null == null renvoie vrai

Dans les leçons précédentes, nous avons expliqué que tout en Java est un objet et que chaque objet a un type.

Que pouvons-nous dire de null à cet égard ? null est un littéral d'un certain type, et ce type n'a pas de nom. Et puisque ce type n'a pas de nom, il est impossible de déclarer une variable de ce type, ou de lui transtyper. Ainsi, null est le seul représentant de ce type sans nom. En pratique, nous pouvons ignorer ce type et considérer null comme un littéral spécial pouvant être affecté à n'importe quelle variable de référence.

Choses dont il faut se rappeler:

• null est la valeur par défaut pour les types de données de référence
• null signifie "pas de valeur"
• Si nous appelons une méthode sur un objet dont la valeur est null , le code se compilera mais à l'exécution nous obtiendrons une NullPointerException .