DATOS INTERESANTES SOBRE NULO EN JAVA

Casi todos los lenguajes de programación están vinculados con nulo. Difícilmente hay un programador al que no le preocupe nulo. En Java, null está asociado java.lang. Excepción de puntero nulo . Como es una clase en el paquete java.lang, se llama cuando intentamos realizar algunas operaciones con o sin nulo y, a veces, ni siquiera sabemos dónde sucedió. A continuación se detallan algunos puntos importantes sobre null en Java que todo programador de Java debería conocer:

En Java, nulo es un valor especial que representa la ausencia de un valor o referencia. Se utiliza para indicar que una variable u objeto actualmente no tiene un valor asignado.
El valor nulo no es lo mismo que una cadena vacía o una matriz vacía. Una cadena vacía es una cadena que no contiene caracteres, mientras que una matriz vacía es una matriz que no contiene elementos.
El lenguaje de programación Java tiene un tipo nulo incorporado llamado "nulo", que es un subtipo de todos los tipos de referencia. Sin embargo, no se puede utilizar como tipo para una variable porque no tiene ninguna instancia y no se puede crear una instancia.
Se considera una práctica recomendada comprobar si hay valores nulos antes de realizar cualquier operación con ellos para evitar el riesgo de una NullPointerException (NPE). NPE se considera una de las excepciones más comunes en Java y puede provocar comportamientos inesperados o fallos en un programa.
En Java, nulo también se usa para indicar que un método no devuelve ningún valor. Esto se conoce como tipo de devolución "nulo". Un método void no devuelve ningún valor y normalmente se usa para realizar una acción como imprimir en la consola o actualizar una base de datos.
Además, null se puede utilizar como valor predeterminado para parámetros opcionales en un método. Esto permite llamar a un método sin especificar un valor para ese parámetro y en su lugar se utilizará el valor nulo.
No se recomienda utilizar null como valor para una variable u objeto destinado a contener un valor de un tipo de datos primitivo como int o double porque provocará un error en tiempo de compilación.
El uso de null en Java puede ser una fuente de confusión y errores sutiles, por lo que es importante conocer su comportamiento y cómo manejarlo adecuadamente en su código para evitar errores.

1. null distingue entre mayúsculas y minúsculas: null es literal en Java y debido a que las palabras clave son distingue mayúsculas y minúsculas En Java no podemos escribir NULL o 0 como en lenguaje C.

Java

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

Producción:

 5: error: cannot find symbol   
  can't find symbol 'NULL'   
  ^   
  variable NULL   
  class Test   
 1 error       2. Valor de la variable de referencia:    Cualquier variable de referencia en Java tiene un valor predeterminado     nulo    .   
 Java      public     class   Test   {      private     static     Object     obj  ;         public     static     void     main  (  String     args  []  )      {      // it will print null;      System  .  out  .  println  (  &  quot  ;  Value     of     object     obj     is     :     &  quot  ;     +     obj  );      }      }   
    Producción:  
  Value of object obj is : null       3. Tipo de nula:    A diferencia del error común, null no es un objeto ni un tipo. Es solo un valor especial que se puede asignar a cualquier tipo de referencia y puedes escribir cast null a cualquier tipo. Ejemplos:  
   // 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 y unboxing:    Durante las operaciones de empaquetado y desempaquetado automático, el compilador simplemente arroja un error de excepción de puntero nulo si se asigna un valor nulo a un tipo de datos encuadrado primitivo.   
 Java      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  ;      }   }   
    Producción:  
   Exception in thread 'main' java.lang.NullPointerException   
  at Test.main(Test.java:6)       5. instancia del operador:    El operador instancia de Java se utiliza para probar si el objeto es una instancia del tipo especificado (clase, subclase o interfaz). En tiempo de ejecución, el resultado del operador instancia de es verdadero si el valor de la expresión no es nulo. Esta es una propiedad importante de la operación instancia de que la hace útil para comprobaciones de conversión de tipos.   
 Java      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  );      }   }   
    Producción:  
  false    
 true      6. Métodos estáticos versus no estáticos:    No podemos llamar a un método no estático en una variable de referencia con valor nulo, ya que generará NullPointerException, pero podemos llamar a un método estático con variables de referencia con valores nulos. Dado que los métodos estáticos están vinculados mediante enlace estático, no generarán una excepción de puntero nulo.   
 Java      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  (      &  quot  ;     static     method        can     be     called     by     null     reference     &     quot  ;);      }      private     void     nonStaticMethod  ()      {      // Can not be called by null reference      System  .  out  .  print  (  &  quot  ;      Non     -     static     method     -     &  quot  ;);      System  .  out  .  println  (      &  quot  ;      cannot     be     called     by     null     reference     &     quot  ;);      }   }   
    Producción:  
  static method can be called by null referenceException in thread 'main'    
 java.lang.NullPointerException   
  at Test.main(Test.java:5)       7. == y !=    Los operadores de comparación y no igual a están permitidos con nulo en Java. Esto puede resultar útil para comprobar nulos con objetos en Java.   
 Java      public     class   Test     {      public     static     void     main  (  String     args  []  )      {      // return true;      System  .  out  .  println  (  null     ==     null  );      // return false;      System  .  out  .  println  (  null     !=     null  );      }   }   
    Producción:  
  true   
 false      8    .     'nulo' se puede pasar como argumento en el método:    
  Podemos pasar el valor nulo como argumento en Java y podemos imprimir lo mismo. El tipo de datos del argumento debe ser Tipo de referencia. Pero el tipo de método devuelto podría ser cualquier tipo como void int double o cualquier otro tipo de referencia dependiendo de la lógica del programa.  
  Aquí el método 'print_null' simplemente imprimirá el argumento que se pasa desde el método principal.  
 Java      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  );      }   }   
       Producción :    
      Hola, soy: nulo    
 
     9. Operador '+' en nulo:    
  Podemos concatenar el valor nulo con variables String en java. Se considera una concatenación en Java.  
  Aquí el nulo solo se concatenará con la variable String. Si utilizamos el operador '+' con nulo y cualquier otro tipo (Entero Doble, etc.) que no sea Cadena, se generará un mensaje de error.   
  El entero a=null+7 arrojará un mensaje de error como '     tipos de operandos incorrectos para el operador binario '+' '    
 Java      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  );      }   }   
    
  Producción   Concatenated value : null_value