Gairebé tots els llenguatges de programació estan units amb null. Gairebé no hi ha un programador que no tingui problemes per nul. A Java, null està associat java.lang. NullPointerException . Com que és una classe del paquet java.lang s'anomena quan intentem fer algunes operacions amb o sense null i de vegades ni tan sols sabem on ha passat. A continuació es mostren alguns punts importants sobre null a Java que tots els programadors de Java haurien de conèixer: 

què és un personatge especial

• A Java, null és un valor especial que representa l'absència d'un valor o referència. S'utilitza per indicar que una variable o objecte actualment no té un valor assignat.
• El valor nul no és el mateix que una cadena buida o una matriu buida. Una cadena buida és una cadena que no conté caràcters, mentre que una matriu buida és una matriu que no conté elements.
• El llenguatge de programació Java té un tipus nul integrat anomenat "nul", que és un subtipus de tots els tipus de referència. No obstant això, no es pot utilitzar com a tipus per a una variable perquè no té cap instància i no es pot instanciar.
• Es considera una pràctica recomanada comprovar els valors nuls abans de realitzar-hi qualsevol operació per evitar el risc d'una NullPointerException (NPE). NPE es considera una de les excepcions més comunes a Java i pot provocar un comportament inesperat o bloquejos en un programa.
• A Java també s'utilitza null per indicar que un mètode no retorna cap valor. Això es coneix com a tipus de retorn "buit". Un mètode void no retorna cap valor i normalment s'utilitza per dur a terme una acció com ara imprimir a la consola o actualitzar una base de dades.
• A més, null es pot utilitzar com a valor predeterminat per als paràmetres opcionals d'un mètode. Això permet cridar un mètode sense especificar un valor per a aquest paràmetre i s'utilitzarà el valor nul.
• No es recomana utilitzar null com a valor per a una variable o objecte que tingui la intenció de contenir un valor d'un tipus de dades primitiu com int o double perquè provocarà un error en temps de compilació.
• L'ús de null a Java pot ser una font de confusió i errors subtils, per la qual cosa és important ser conscient del seu comportament i de com gestionar-lo correctament al codi per evitar errors.

1. null distingeix entre majúscules i minúscules: null és literal a Java i perquè les paraules clau ho són distingeix entre majúscules i minúscules a Java no podem escriure NULL o 0 com en llenguatge C. 

public class Test {  public static void main (String[] args) throws java.lang.Exception  {  // compile-time error : can't find symbol 'NULL'  Object obj = NULL;     //runs successfully  Object obj1 = null;   } } 

Sortida:

5: error: cannot find symbol  
 can't find symbol 'NULL'  
 ^  
 variable NULL  
 class Test  
1 error 

2. Valor de la variable de referència: Qualsevol variable de referència a Java té un valor per defecte nul·la . 

public class Test {  private static Object obj;   public static void main(String args[])  {  // it will print null;  System.out.println("Value of object obj is : " + obj);  }  } 

Sortida:

Value of object obj is : null 

3. Tipus de nul·la: A diferència de la concepció errònia comuna, null no és Object ni tampoc un tipus. És només un valor especial que es pot assignar a qualsevol tipus de referència i podeu escriure cast null a qualsevol tipus. Exemples:

 // null can be assigned to String  
 String str = null;   
   
 // you can assign null to Integer also  
 Integer itr = null;   
   
 // null can also be assigned to Double  
 Double dbl = null;   
   
 // null can be type cast to String  
 String myStr = (String) null;   
   
 // it can also be type casted to Integer  
 Integer myItr = (Integer) null;   
   
 // yes it's possible no error  
 Double myDbl = (Double) null; 

4. Autoboxing i unboxing: Durant les operacions d'auto-boxing i unboxing, el compilador simplement llança un error d'excepció de Nullpointer si s'assigna un valor nul al tipus de dades en caixa primitiu. 

public class Test {  public static void main(String[] args)  throws java.lang.Exception  {  // An integer can be null so this is fine  Integer i = null;  // Unboxing null to integer throws  // NullpointerException  int a = i;  } } 

Sortida:

 Exception in thread 'main' java.lang.NullPointerException  
 at Test.main(Test.java:6) 

5. instanceof operador: L'operador java instanceof s'utilitza per provar si l'objecte és una instància del tipus especificat (classe o subclasse o interfície). En temps d'execució, el resultat de l'operador instanceof és cert si el valor de l'expressió no és nul. Aquesta és una propietat important de l'instancia d'operació que la fa útil per a les comprovacions de llançament de tipus. 

public class Test {  public static void main(String[] args)  throws java.lang.Exception  {  Integer i = null;  Integer j = 10;  // prints false  System.out.println(i instanceof Integer);  // Compiles successfully  System.out.println(j instanceof Integer);  } } 

Sortida:

false   
true

6. Mètodes estàtics i no estàtics: No podem cridar un mètode no estàtic en una variable de referència amb valor nul, generarà NullPointerException, però podem cridar un mètode estàtic amb variables de referència amb valors nuls. Com que els mètodes estàtics s'uneixen mitjançant l'enllaç estàtic, no llançaran l'excepció de punter nul. 

public class Test {  public static void main(String args[])  {  Test obj = null;  obj.staticMethod();  obj.nonStaticMethod();  }  private static void staticMethod()  {  // Can be called by null reference  System.out.println(  " static method  can be called by null reference & quot;);  }  private void nonStaticMethod()  {  // Can not be called by null reference  System.out.print("  Non - static method - ");  System.out.println(  "  cannot be called by null reference & quot;);  } } 

Sortida:

static method can be called by null referenceException in thread 'main'   
java.lang.NullPointerException  
 at Test.main(Test.java:5) 

7. == i != La comparació i no igual als operadors es permet amb null a Java. Això pot ser útil per comprovar null amb objectes a Java. 

public class Test {  public static void main(String args[])  {  // return true;  System.out.println(null == null);  // return false;  System.out.println(null != null);  } } 

Sortida:

true  
false

8 . 'null' es pot passar com a argument al mètode:

Podem passar el null com a argument en Java i podem imprimir el mateix. El tipus de dades de l'argument hauria de ser Tipus de referència. Però el tipus de mètode de retorn podria ser qualsevol tipus com a void int double o qualsevol altre tipus de referència depenent de la lògica del programa.

Aquí el mètode 'print_null' simplement imprimirà l'argument que es passa des del mètode principal.

import java.io.*; class GFG {  public static void print_null(String str)  {  System.out.println('Hey I am : ' + str);  }  public static void main(String[] args)  {  GFG.print_null(null);  } } 

Sortida:

Hola sóc: nul

9. Operador '+' a null:

Podem concatenar el valor nul amb variables String a Java. Es considera una concatenació en java.

Aquí el null només es concatenarà amb la variable String. Si utilitzem l'operador '+' amb null i qualsevol altre tipus (Doble Sencer, etc.) que no sigui String, llançarà un missatge d'error. 

El nombre enter a=null+7 llançarà un missatge d'error com a " tipus d'operands dolents per a l'operador binari '+' '

import java.io.*; class GFG {  public static void main(String[] args)  {  String str1 = null;  String str2 = '_value';  String output = str1 + str2;  System.out.println('Concatenated value : '  + output);  } } 

Concatenated value : null_value