Datos interesantes sobre nulo en Java

Casi todos los lenguajes de programación están enlazados con nulo. Apenas hay un programador que no esté preocupado por nulo. En Java, nulo está asociado a java.lang. NullPointerException . 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 ha sucedido. A continuación se presentan algunos puntos importantes sobre nulo en Java que todo programador de Java debería saber: 

1. null distingue entre mayúsculas y minúsculas: null es literal en Java y debido a que las palabras clave distinguen entre mayúsculas y minúsculas en java, no podemos escribir NULL o 0 como en el lenguaje 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;
    }
}

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 . 

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

Producción:

Value of object obj is : null 

3. Tipo de nulo: a diferencia del concepto erróneo común, nulo no es un objeto ni un tipo. Es solo un valor especial, que se puede asignar a cualquier tipo de referencia y puede 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 auto-boxing y unboxing, el compilador simplemente arroja un error de excepción Nullpointer si se asigna un valor nulo al tipo de datos primitivo en caja. 

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. Operador instanceof: El operador java instanceof se utiliza para comprobar si el objeto es una instancia del tipo especificado (clase, subclase o interfaz). En tiempo de ejecución, el resultado del operador instanceof es verdadero si el valor de Expression no es nulo. Esta es una propiedad importante de la operación instanceof que la hace útil para las verificaciones de conversión de tipos. 

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 frente a no estáticos: no podemos llamar a un método no estático en una variable de referencia con valor nulo, lanzará NullPointerException, pero podemos llamar al método estático con variables de referencia con valores nulos. Dado que los métodos estáticos están vinculados mediante un enlace estático, no arrojarán una excepción de puntero nulo. 

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

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 ser útil para verificar nulos con objetos en 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 _ «null» se puede pasar como un argumento en el método:

Podemos pasar el 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 retorno del método 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.

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 : null

9. Operador ‘+’ en nulo:

Podemos concatenar el valor nulo con variables de string en java. Se considera una concatenación en java.

Aquí, el nulo solo se concatenará con la variable String. Si usamos el operador «+» con nulo y cualquier otro tipo (Entero, Doble, etc.) que no sea String, arrojará un mensaje de error. 

El entero a=null+7 arrojará un mensaje de error como » tipos de operandos incorrectos para el operador binario ‘+'»

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

Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. 

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.