¿Qué es una NullPointerException?

Bueno, se trata de un error, o más bien de una excepción que aparece cuando intentamos aplicar operaciones sobre un objeto que es nulo. En Java, al crear cualquier variable de tipo Objeto al inicio apunta a nulo, lo que requiere que dicha variable sea inicializada con su constructor correspondiente. Por tanto, si intentamos acceder a una variable que apunta a nulo, o realizar alguna operación con ella, obtendremos dicha excepción.

A continuación veremos escenarios muy típicos dónde nos salta dicha excepción. Para dichos escenarios vamos a usar una clase muy famosas de Java cuando se está comenzado a programar, aunque con algunas modificaciones y sólo implementando lo más básico. A mí me sirvió de mucha ayuda en mis inicios, dado que con este ejemplo vi a qué se refería la idea de orientación a objetos.

La clase Jarra:

public class Jarra {
    public static String nombre;
    public int capacidad;
    private int cantidad;

    public Jarra(String nombre, int capacidad, int cantidad) {
        Jarra.nombre = nombre;
        this.capacidad = capacidad;
        this.cantidad = cantidad;

        if (cantidad > capacidad) {
            cantidad = capacidad;
        }
    }

    public Jarra(String nombre, int capacidad) {
        this(nombre, capacidad, 0);
    }

    public int getCapacidad() {
        return capacidad;
    }

    public void setCapacidad(int capacidad) {
        this.capacidad = capacidad;

        if (cantidad > capacidad) {
            cantidad = capacidad;
        }
    }

    public int getCantidad() {
        return cantidad;
    }

    public void setCantidad(int cantidad) {
        this.cantidad = cantidad;

        if (cantidad > capacidad) {
            cantidad = capacidad;
        }
    }

    public String toString() {
        return nombre + " - " + cantidad + "/" + capacidad;
    }
}

A continuación vamos a ver los escenarios más comunes en los que podemos ver dicha excepción:

Escenario 1
java.lang.NullPointerException al llamar a un método de instancia sobre objetos nulos.
Este puede que sea el error más común que nos podemos encontrar. En este ejemplo es trivial verlo, es más, Eclipse nos avisa de que el objeto será nulo en ese punto, pero en aplicaciones más grandes puede llegar a ser un gran problema.

Jarra jarraA = null;
System.out.println(jarraA.getCantidad()); //Se lanzará NullPointerException aquí

Recuerda siempre inicializar todos los objetos de forma correcta. Aun así, no obtendremos la excepción si llamamos un método estático. Dichos métodos no requieren una instancia para poder ser llamados.

Escenario 2
java.lang.NullPointerException al acceder a una variable de una referencia nula.
Es muy parecida al caso anterior. Si suponemos que dicha variable es pública, y que puede ser accedida desde el exterior, nos aparecerá nuestra querida excepción.

Jarra jarraA = null;
System.out.println(jarraA.capacidad); //Se lanzará NullPointerException aquí

Escenario 3
java.lang.NullPointerException al lanzar una Excepción cualquiera sin inicializar.
Las excepciones, como todos los demás, son objetos y por tanto han de ser inicializados antes de poder acceder a sus métodos.

RuntimeException excepcionPrueba = null;
throw excepcionPrueba; //Se lanzará NullPointerException aquí

Escenario 4
java.lang.NullPointerException al intentar obtener la longitud de un array que es nulo.

Jarra[] jarrasArray = null;
int longitud = jarrasArray.length; //Se lanzará NullPointerException aquí

Escenario 5
java.lang.NullPointerException al acceder a un elemento de un array que es nulo.

Jarra[] jarrasArray = null;
Jarra jarraB = jarrasArray[1]; //Se lanzará NullPointerException aquí

Obviamente, este escenario y el anterior pueden ser trasladados al uso de cualquier tipo de estructura de datos. En este caso hemos usado los array porque son los objetos más simples que podemos usar, pero por ejemplo se podría haber mostrado con listas o conjuntos.

Escenario 6
java.lang.NullPointerException al intentar usar synchronize sobre objetos nulos o intentar usar objetos nulos dentro de bloques synchronized.

Jarra jarraC = null;
synchronized (jarraC) { //Se lanzará NullPointerException aquí
    System.out.println("Este bloque es synchronized sobre una variable nula");
}

¿Cómo resolver las NullPointerException en Java?

Para resolverlas, lo primero que hemos de conocer es qué las causa. Esto puede llegar a ser una tarea muy sencilla si sabemos dónde buscar. Toda la información que necesitamos la encontremos en la traza de errores en la consola de nuestro entorno de desarrollo (IDE), incluyendo la línea exacta dónde se ha producido el lanzamiento de la excepción y la pila de llamada de métodos antes de que se produjera.

El siguiente paso será buscar en esa línea o adyacentes qué objeto es el que causa la excepción, y ya tenemos la mitad del trabajo hecho. El resto de la tarea será saber por qué ese objeto es nulo en ese momento. Puede que se deba a un error en la creación del objeto o cualquier otro motivo, por lo que esta tarea varía y no puedo dar una solución exacta. A veces la mejor solución es tener mucho cuidado al desarrollar, aplicar técnicas preventivas para objetos nulos y usar métodos Null Safe.

Cuando no aparece NullPointerException

Si accedemos a métodos o clases estáticas nunca obtendremos dicha excepción, incluso si hacemos referencias a variables que apuntan a nulo. Esto es debido a que las variables y métodos estáticos son, en tiempo de compilación, ‘atados’ basándose en el nombre de la clase y no son asociados con objetos. En el siguiente ejemplo no saltará una excepción, dado que la variable nombre es estática, y en su lugar nos imprimirá por pantalla el valor real de la variable, que en este caso es: ‘null’.

Jarra jarraD = null;
System.out.println(jarraD.nombre);

Algunos puntos importantes de las NullPointerException

Para terminar con esta primera parte de la lección vamos a dar algunos consejos, sugerencias y detalles a tener en cuenta con estas caprichosas excepciones.

1. Las NullPointerException con excepciones no comprobadas porque extienden (son hijas de) RuntimeException y por lo tanto no es necesario controlarlas con un bloque try-catch.
2. Cuando obtengas una excepción NullPointerException busca la línea en la que se ha producido para encontrar al objeto que la causa.
3. Los IDE modernos, como por ejemplo Eclipse o Netbeans, nos dan un enlace en la consola para ir directamente a la clase y línea donde se ha producido la excepción.
4. Se pueden usar puntos de ruptura en el modo Debug del IDE para suspender la ejecución del programa cuando la excepción ocurre, de modo que se nos permite ver el valor de todas las variables en memoria y comprobar qué está fallando.
5. Nunca olvides mirar el nombre del hilo de ejecución donde se ha producido la excepción. Si desarrollamos una aplicación multi-hilo se puede poner la cosa muy difícil si por algún motivo algún hilo hace referencia a nulo en algún momento.
6. Lo mejor es evitar las NullPointerException durante el desarrollo siguiendo algunas técnicas de prevención o añadiendo comprobaciones en las bases de datos como restricciones.

Por el momento esto es todo. En la siguiente parte vamos a poner en práctica algunas técnicas de prevención útiles para evitar las NullPointerException en Java.

Saludos,
Lázarus Surazal.