Lenguaje Java

Gestión de excepciones

La gestión de excepciones en Java es muy similar a la de C#, con algunos matices adicionales. Disponemos de los siguientes elementos para controlar las posibles excepciones que se producen en un programa.

• Para capturar una posible excepción en el código, emplearemos un bloque de código try...catch, como en otros lenguajes. En el bloque try pondremos el código que puede provocar el fallo, y en el bloque (o bloques) catch capturaremos los posibles errores que se pueden producir, emitiendo un mensaje de error apropiado, o respondiendo conforme a ese error. Para ello, el objeto con la excepción que se ha producido dispone de un método llamado getMessage(), que devuelve el mensaje de error.
• Todas las excepciones que se producen en Java derivan de un tipo base llamado Exception. Podemos emplear este tipo base en una cláusula catch para capturar tipos de excepciones no contemplados en otras cláusulas catch previas.
• Para lanzar o provocar una excepción cuando detectamos un error emplearemos la cláusula throw con la excepción que queramos lanzar. Ésta deberá ser capturada por un bloque try...catch en algún lugar del código. Adicionalmente, dependiendo del tipo de excepción en sí, puede también ser necesario indicar en la función donde estamos que dicha función puede lanzar ese tipo de excepciones, con la cláusula throws.
• Existe también un bloque llamado finally, que se coloca tras los bloques catch, y está destinado a operaciones que deben hacerse en cualquier caso, tanto si se produce un error como si no. Típicamente se utiliza para cerrar conexiones abiertas a ficheros, bases de datos, etc.

Veamos algunos ejemplos:

• Esta función lanza una excepción de tipo IllegalArgumentException si el segundo parámetro que recibe es 0, indicando que no se pueden dividir entre sí:

public static int dividir(int dividendo, int divisor)
{
    if (divisor == 0)
        throw new IllegalArgumentException("Error: no se puede dividir por 0");
    else
        return dividendo / divisor;
}

• Este ejemplo es igual que el anterior, pero además, indicamos en la propia función dividir que dicha función puede lanzar excepciones de tipo IllegalArgumentException. Esta cláusula throws es opcional en algunos tipos de excepciones, y obligatoria en otros (dará error de compilación si no la ponemos).

public static int dividir(int dividendo, int divisor) throws IllegalArgumentException
{
    if (divisor == 0)
        throw new IllegalArgumentException("Error: no se puede dividir por 0");
    else
        return dividendo / divisor;
}

• Este código llama a la función anterior y captura la posible excepción:

try
{
    int resultado = dividir(5, 2);
    System.out.println(resultado);
}
catch(IllegalArgumentException e)
{
    System.out.println(e.getMessage());
}

• Este otro código es un ejemplo de cómo capturar distintos tipos de excepciones, y de cómo usar la cláusula finally al final. Las capturas con catch se deben colocar de más concretas a más generales, para que la última englobe cualquier tipo de error no contemplado en las anteriores

try
{
    // Código que puede provocar un error
}
catch (IllegalArgumentException e1)
{
    System.out.println("Error al dividir por cero: " + e1.getMessage());
}
catch (Exception e2)
{
    System.out.println("Error inesperado");
}
finally
{
    // Cerrar fichero, conexión a BD, etc.
}