Excepción de puntero nulo en Java

NullPointerException es una RuntimeException. En Java , se puede asignar un valor nulo especial a una referencia de objeto. NullPointerException se lanza cuando el programa intenta usar una referencia de objeto que tiene el valor nulo.
Estos pueden ser: 
 

• Invocar un método desde un objeto nulo.
• Acceder o modificar el campo de un objeto nulo.
• Tomando la longitud de nulo, como si fuera un arreglo.
• Accediendo o modificando las ranuras del objeto nulo, como si fuera una array.
• Lanzar nulo, como si fuera un valor Throwable.
• Cuando intenta sincronizar sobre un objeto nulo.

¿Por qué necesitamos el valor nulo?  
Null es un valor especial utilizado en Java. Se utiliza principalmente para indicar que no se asigna ningún valor a una variable de referencia. Una aplicación de nulo es la implementación de estructuras de datos como listas vinculadas y árboles. Otras aplicaciones incluyen el patrón de objeto nulo (ver esto para más detalles) y el patrón Singleton . El patrón Singleton asegura que solo se crea una instancia de una clase y también tiene como objetivo proporcionar un punto de acceso global al objeto.
Una forma de muestra de crear como máximo una instancia de una clase es declarar todos sus constructores como privados y luego crear un método público que devuelva la instancia única de la clase:
 

// To use randomUUID function.
import java.util.UUID;
import java.io.*;
 
class Singleton
{
    // Initializing values of single and ID to null.
    private static Singleton single = null;
    private String ID = null;
 
    private Singleton()
    {
        /* Make it private, in order to prevent the
           creation of new instances of the Singleton
           class. */
 
        // Create a random ID
        ID = UUID.randomUUID().toString();
    }
 
    public static Singleton getInstance()
    {
        if (single == null)
            single = new Singleton();
        return single;
    }
 
    public String getID()
    {
        return this.ID;
    }
}
 
// Driver Code
public class TestSingleton
{
    public static void main(String[] args)
    {
        Singleton s = Singleton.getInstance();
        System.out.println(s.getID());
    }
}

Producción: 
 

10099197-8c2d-4638-9371-e88c820a9af2

En el ejemplo anterior, una instancia estática de la clase singleton. Esa instancia se inicializa como máximo una vez dentro del método Singleton getInstance.
¿Cómo evitar la NullPointerException?  
Para evitar la excepción NullPointerException, debemos asegurarnos de que todos los objetos se inicialicen correctamente antes de usarlos. Cuando declaramos una variable de referencia, debemos verificar que el objeto no sea nulo, antes de solicitar un método o un campo de los objetos.
Los siguientes son los problemas comunes con la solución para superar ese problema.
 

Caso 1: comparación de strings con literales

Un problema de caso muy común implica la comparación entre una variable de string y un literal. El literal puede ser un String o un elemento de un Enum. En lugar de invocar el método desde el objeto nulo, considere invocarlo desde el literal. 
 

// A Java program to demonstrate that invoking a method
// on null causes NullPointerException
import java.io.*;
 
class GFG
{
    public static void main (String[] args)
    {
        // Initializing String variable with null value
        String ptr = null;
 
        // Checking if ptr.equals null or works fine.
        try
        {
            // This line of code throws NullPointerException
            // because ptr is null
            if (ptr.equals("gfg"))
                System.out.print("Same");
            else
                System.out.print("Not Same");
        }
        catch(NullPointerException e)
        {
            System.out.print("NullPointerException Caught");
        }
    }
}

Producción: 
 

NullPointerException Caught

Podemos evitar NullPointerException llamando a equals en literal en lugar de objeto.
 

// A Java program to demonstrate that we can avoid
// NullPointerException
import java.io.*;
 
class GFG
{
    public static void main (String[] args)
    {
        // Initializing String variable with null value
        String ptr = null;
 
        // Checking if ptr is null using try catch.
        try
        {
            if ("gfg".equals(ptr))
                System.out.print("Same");
            else
                System.out.print("Not Same");           
        }
        catch(NullPointerException e)
        {
            System.out.print("Caught NullPointerException");
        }
    }
}

Producción: 
 

Not Same

Caso 2: Controlar los argumentos de un método

Antes de ejecutar el cuerpo de su nuevo método, primero debemos verificar sus argumentos en busca de valores nulos y continuar con la ejecución del método, solo cuando los argumentos estén debidamente verificados. De lo contrario, lanzará una IllegalArgumentException y notificará al método de llamada que algo anda mal con los argumentos pasados. 
 

// A Java program to demonstrate that we should
// check if parameters are null or not before
// using them.
import java.io.*;
 
class GFG
{
    public static void main (String[] args)
    {
        // String s set an empty string  and calling getLength()
        String s = "";
        try
        {
            System.out.println(getLength(s));
        }
        catch(IllegalArgumentException e)
        {
            System.out.println("IllegalArgumentException caught");
        }
 
        // String s set to a value and calling getLength()
        s = "GeeksforGeeks";
        try
        {
            System.out.println(getLength(s));
        }
        catch(IllegalArgumentException e)
        {
            System.out.println("IllegalArgumentException caught");
        }
 
        // Setting s as null and calling getLength()
        s = null;
        try
        {
            System.out.println(getLength(s));
        }
        catch(IllegalArgumentException e)
        {
            System.out.println("IllegalArgumentException caught");
        }
    }
 
    // Function to return length of string s. It throws
    // IllegalArgumentException if s is null.
    public static int getLength(String s)
    {
        if (s == null)
            throw new IllegalArgumentException("The argument cannot be null");
        return s.length();
    }
}

Producción: 
 

0
13
IllegalArgumentException caught

Caso 3: uso del operador ternario

El operador ternario se puede utilizar para evitar NullPointerException. Primero, se evalúa la expresión booleana. Si la expresión es verdadera , se devuelve el valor 1; de lo contrario, se devuelve el valor 2. Podemos usar el operador ternario para manejar punteros nulos:
 

// A Java program to demonstrate that we can use
// ternary operator to avoid NullPointerException.
import java.io.*;
 
class GFG
{
    public static void main (String[] args)
    {
        // Initializing String variable with null value
        String str = null;
        String message = (str == null) ? "" :
                          str.substring(0,5);
        System.out.println(message);
 
        // Initializing String variable with null value
        str = "Geeksforgeeks";
        message = (str == null) ? "" : str.substring(0,5);
        System.out.println(message);
    }
}

Producción: 
 

Geeks

La variable del mensaje estará vacía si la referencia de str es nula como en el caso 1. De lo contrario, si str apunta a datos reales , el mensaje recuperará los primeros 6 caracteres como en el caso 2.
Artículo relacionado: datos interesantes sobre Null en Java 
 
Esto el artículo es aportado por Nikhil Meherwal . 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.