Control de excepciones

Hoy aprenderemos como funcionan los errores y las excepciones en Java.

Descubriremos como tratarlas, manejarlas y por qué se producen algunas de
ellas. Las excepciones en Java ocurren en tiempo de ejecución, es decir, que no
sabemos si van a producirse o no hasta que el programa se ejecuta y comienza
a funcionar. Controlar excepciones es de vital importancia, ya que nos permitirá
prevenir posibles errores inesperados de nuestro programa o de la misma
máquina virtual de Java.
Antes de conocer como controlar las excepciones, es interesante saber que
existen dos tipos de excepciones ‘madre’, por decirlo de alguna forma: ‘Error’ y
‘Excepcion’, ambas tiene a su vez una clase madre común
denominada ‘Throwable’, con varios métodos que nos permiten conocer el
origen de la excepción. De esas dos excepciones deriva todo un árbol de tipos
de excepciones que refleja hasta los errores más concretos en la ejecución del
programa. En Java, las excepciones se representan por medio de una clase. Lo
que verdaderamente está ocurriendo cuando se genera un error es que el
programa detiene su curso normal de ejecución, nos devuelve un objeto creado
a través de la clase de la excepción y ejecuta un bloque de código que nosotros
le hayamos indicado en caso de que ocurriera.
Nos centraremos en las excepciones generadas a partir de la clase ‘Excepcion’,
ya que son las correspondientes a errores en nuestro programa. Por otro lado,
las excepciones generadas a partir de ‘Error’ implican errores en la propia
máquina virtual de Java que ejecuta nuestro programa.
¿Te sientes un poco confuso? No te preocupes, la teoría puede resultar un poco
difícil de comprender a la primera, pero descubrirás que es más sencillo de lo
que parece. En resumen, ocurriría lo siguientecuando se produce un errror en
nuestro programa:

1. Se ejecuta el programa con normalidad.

2. En cierto punto, ocurre un error. Se interrumpe la ejecución normal del
programa.
3. Se lanza automáticamente una excepción, nos devuelve un objeto
heredado de ‘Excepcion’ de un tipo particular, con la información del error.
4. Capturamos la excepción. Es decir, capturamos el objeto que nos ha
devuelto.
5. Se ejecuta el código preparado en caso de que la excepción ocurriera.
6. El programa continua la ejecución por el código posterior al bloque
preparado para capturar excepciones.

Hemos hablado de capturar una excepción, pero no hemos hablado de cómo.

Java pone a nuestra disposición un conjunto de sentencias para manejar
excepciones que nos permitirán capturarlas e incluso ejecutar más código
después de que ocurran.

Instrucción TRY-CATCH
Mediante ésta instrucción podremos capturar las excepciones que se generen
entre sus llaves. Veamos que estructura seguiría la declaración de un try-catch:
1
try {
2 // BLOQUE DE CÓDIGO.
3 // - Los errores ocurridos aquí pueden ser capturados.
4 } catch (TipoExcepcion nombreObjeto){
5 // Código a ejecutar si ocurre un error y lanza una excepción TipoExcepcion.
6 } catch (TipoExcepcion2 nombreObjeto2){
// Código a ejecutar si ocurre un error y lanza una excepción TipoExcepcion2.
7 }
8
Se puede observar que primero escribimos try y abrimos unas llaves. El código
situado entre esas llaves es el que el programa ejecutará con normalidad
y cualquier error ocurrido en su interior podrá ser controlado. Por otra parte, el
código que pongamos dentro de las llaves de catch solo será ejecutado si se
lanza un error del tipo indicado entre los paréntesis.
Recordemos que cuando ocurre un error, nuestro programa devuelve un objeto
correspondiente a una excepción con un tipo particular que dependerá del tipo
de error generado. Lo que nosotros controlamos mediante catch es el tipo de
excepción generada y que hacer en cada caso particular.
Veamos un ejemplo práctico:
01
02 int lista[] = new int[3];
03
try {
04 System.out.println("Hola");
05 num[5] = 10;
06 System.out.println("Adios");
07 } catch (ArrayIndexOutOfBoundsException ex) {
System.out.println("Error: Posicion no valida.");
08 }
09
10 System.out.println("Fin del programa");
11
Observemos qué ocurre aquí:

1. El programa comienza creando una lista de 3 elementos. (Posiciones 0, 1

y 2).
2. Entra al bloque de código preparado para capturar excepciones, el
encerrado por las llaves de TRY.
3. Imprime “Hola”.
4. Intenta acceder a una posición de la lista que no existe, ya que es
demasiado elevada.
5. No puede acceder por lo que lanza una excepción del tipo
ArrayIndexOutOfBounds, recordamos que en verdad es un objeto
heredado de Exception, por lo que lo capturamos.
6. El programa pasa directamente a la sentencia CATCH, donde captura el
objeto del tipo ArrayIndexOutOfBounds y lo llama ex. Ahora ex es un
objeto correspondiente a una excepción.
7. Ejecuta el código correspondiente al CATCH que ha capturado la
excepción, en este caso imprime un mensaje de error.
 8. Continua la ejecución normal del programa por el código correspondiente
al posterior de la instrucción TRY-CATCH. Imprime “Fin del programa”.

Observa que no ha imprimido el mensaje “Adios”. Esto se debe a que en el

momento en que se produce un error, el programa va directamente a comprobar
si la excepción está siendo capturada por algún CATCH para ejecutar ese
código.
¿Qué ocurre cuando el programa lanza una excepción y no la
capturamos con TRY-CATCH? El programa finalizará bruscamente y
mostrará un mensaje de error indicando el tipo de excepción. Esos
mensajes de error suelen ser parecidos la siguiente
Exception in thead “main” java.lang.ArrayIndexOutOfBoundsException: 7
at NotHandled.main(NotHandled.java:9)
Podemos indicar tantas sentencias CATCH como queramos, ya que por las
necesidades de nuestro programa, puede interesarnos manejar de formas
diferentes determinados tipos de errores.

Capturar cualquier excepción con ‘Exception’

¿Se puede capturar una excepción mediante CATCH sea del tipo que sea? La
respuesta es SI. Como hemos mencionado anteriormente, todas las clases que
representan las excepciones heredan de una clase madre denominada
‘Exception’. Por lo tanto, podemos capturar con una sentencia CATCH una
excepción del tipo ‘Excepción’, que capturará cualquier error que se produzca
dentro del bloque de TRY, sea del tipo que sea. Por decirlo de algún modo más
sencillo, capturar la clase madre es como capturar a cualquiera de sus hijas. Por
ejemplo:
1 try {
2 // BLOQUE DE CÓDIGO.
3 } catch (Exception ex){
4 System.out.println("Ha ocurrido un error.");
}
5
El código anterior capturará cualquier error que se produzca, sea del tipo que
sea y mostrará un mensaje de error indicado por nosotros. El único problema de
utilizar este método para capturar excepciones, es que no tenemos una forma
concreta para manejar diferentes tipos de errores y sea cual sea la excepción, el
código ejecutado será el mismo.

Sentencia FINALLY
En casos particulares, quizás nos interesa ejecutar un bloque de código después
del CATCH en caso de que se produzca un error durante la ejecución de nuestro
programa. Aunque a priori pueda resultar poco útil, puede llegar a ser necesario
para programas más complejos donde por ejemplo, es necesario cerrar una
conexión en caso de que se produzca un error.
¿Qué hace exactamente la intrucción FINALLY? En el caso de que se produzca
un error, ejecutará un bloque de código después de que haya sido capturado por
CATCH.
Pongamos un ejemplo:
1
try {
2 // BLOQUE DE CÓDIGO.
3 } catch (Exception ex){
4 System.out.println("Ha ocurrido un error.");
5 } finally {
6 System.out.println("Excepcion capturada");
}
7
8 System.out.println("Adios.");
9
Veamos cómo se comporta el programa en el caso de que SI ocurra un error:

1. El programa ejecuta el bloque de código y lanza una excepción.

2. Se captura en el CATCH e imprime un mensaje. “Ha ocurrido un error”.
3. Se ha lanzado una excepción, por lo que también se ejecuta
FINALLY. Imprime: “Excepción capturada”.
4. El programa continua ejecutándose e imprime: “Adios”.

Veamos cómo se comporta el programa en el caso de que NO ocurra un error:

1. El programa ejecuta el bloque de código.

2. No ha ocurrido ningún error, por lo que NO se ejecuta CATCH ni
FINALLY.
3. El programa continua ejecutándose e imprime: “Adios”.

Espero que hayas comprendido cómo funcionaría FINALLY en este caso.

Sentencia THROWS
El programador también puede decidir si quiere lanzar una excepción si se
genera una determinada situación en su código, en vez de que sea su programa
el que lo haga. Es importante que siempre debemos indicar el tipo de excepción
que queremos lanzar. Para poder hacerlo, utilizaremos una sentencia
denominada THROW, que nos permitirá lanzar a nosotros mismos una
excepción.
Veamos un código para comprenderlo mejor:
1
int numero1 = 5;
2 int numero2 = 0;
3 try {
4 if (numero2 == 0) throws new ArithmeticException();
5 } catch (ArithmeticException ex){
6 System.out.println("Ha ocurrido un error.");
}
7
8 System.out.println("Adios.");
9
Lo que está ocurriendo es que throw está creando un objeto del tipo
ArithmeticException y lo está lanzando. Es exactamente igual a cuando el
programa lanza una excepción, es decir, un objeto del tipo de excepción
correspondiente, con la diferencia de que en este caso la excepción la lanzamos
nosotros y lanzamos el objeto correspondiente.
¿Sabrías decir de que tipo será la excepción en el código anterior? Si nos
fijamos, estamos lanzando una excepción del tipo ArithmeticException.

Lista de excepciones
Mostramos a continuación una tabla con todas las excepciones que podemos
encontrar en Java. Es interesante saber que muchas de ellas, el mismo lenguaje
nos obligará a encerrarlas en un bloque TRY-CATCH para garantizar el buen
funcionamiento del programa.

EXCEPCIÓN SIGNIFICADO

ArithmeticException Error aritmético. Ejemplo: número dividido entre 0.

ArrayIndexOutOfBoundsException El índice de la matriz supera sus límites.

ArrayStoreException Asignación de un elemento de matriz de un tipo incompatible.

ClassCastException Conversión inválida.

EnumConstantNotPresentException Se intenta usar un valor de enumeración sin definir.

IllegalArgumentException Argumento ilegal usado para invocar un método.

IllegalMonitorStateException Operación de monitor ilegal: Ejemplo: espera de un subproceso de

IllegalStateException El estado del entorno o la aplicación es incorrecto.

IllegalThreadStateException La operación solicitada no es compatible con el estado del subproc

IndexOutOfBoundsException Algún tipo de índice supera los límites.

NegativeArraySizeException Matriz creada con un tamaño negativo.

NullPointerException Uso incorrecto de una referencia ‘null’.

NumberFormatException Conversión incorrecta de una cadena a un formato numérico.

SecurityException Intento de violación de seguridad.

StringIndexOutOfBoundsException Intento de indexar fuera de los límites de una cadena.

TypeNotPresentException Tipo no encontrado.

UnsupportedOperationException Se ha detectado una operación no admitida.

ClassNotFoundException Clase no encontrada.

CloneNotSupportedException Intento de clonar un objeto que no implemente la interfaz Cloneab

IllegalAccessException Acceso denegado a una clase.

InstantiationException Intento de crear un objeto de una clase o interfaz abstracta.

InterruptedException Un subproceso ha interrumpido a otro.

NoSuchFileException No existe el campo solicitado.

NoSuchMethodException No existe el método solicitado.

ReflectiveOperationException Superclase de exceptiones relacionada con la reflexión.