Manejo de excepciones en Java

A los errores en tiempo de ejecución se les conoce como excepciones, estas interrumpen el flujo normal de las sentencias. Básicamente una excepción es un objeto descendiente de la clase java.lang.Object. En la programación siempre se producen errores que deben ser gestionados y tratados correctamente. Es por ello que en java se cuenta con un mecanismo consistente en el uso de bloques try/catch/finally.

Esta técnica consiste en colocar instrucciones que podrían provocar problemas dentro del bloque try, y colocar enseguida uno o más bloques catch, de tal manera que si se provoca un error de un determinado tipo, lo que se hará es saltar al bloque catch capaz de gestionar este tipo de error especifico, en tal caso que no se hayan provocado errores en el bloque try, nunca se ejecutarán los bloques catch.

El bloque finally siempre se ejecutará independientemente de si se da o no una excepción. Es opcional y se usa generalmente para liberar recursos.

A continuación se muestra la estructura del bloque try/catch/finally:

try { //Código que puede provocar errores } catch(Tipo1 var1) {

//Gestión del error var1, de tipo Tipo1 } [

catch(TipoN varN) {

//Gestión del error varN, de tipo TipoN } ] [ finally {

//Código de finally } ]

Existen dos categorías de excepciones:

Excepciones checked

Constituyen un error del cual se puede recuperarse. Por ejemplo, una operación de lectura/escritura en disco puede fallar porque el fichero no existe, porque ese se encuentre bloqueado por otra aplicación, etc.

Todas estas situaciones, además de ser inherentes al propósito del código que las lanza son totalmente ajenas al propio código, y deben ser declaradas y manejadas por medio de excepciones de tipo checked.

En conclusión, todas las excepciones de tipo checked deben ser capturadas o relanzadas. Ejemplo:

import java.io.FileWriter; import java.io.IOException; public class Main { public static void main(String[] args) { FileWriter fichero; try { // Las siguientes dos líneas pueden lanzar una excepción de tipo IOException fichero = new FileWriter("ruta"); fichero.write("Esto se escribirá en el fichero"); } catch (IOException ioex) { // Aquí capturamos cualquier excepción IOException que se lance (incluidas sus subclases) ioex.printStackTrace(); } } }

En caso de querer relanzar la excepción, se debe declarar dicha intención en la firma del método que contiene las sentencias que lanzan la excepción y se realiza mediante la cláusula throws.

import java.io.FileWriter; import java.io.IOException;

public class Main { // En lugar de capturar una posible excepción, la relanzamos

public static void main(String[] args) throws IOException { FileWriter fichero = new FileWriter("ruta"); fichero.write("Esto se escribirá en el fichero"); } }

Excepciones unchecked:

Representan un error de programación. Uno de los ejemplos más típicos es el de quererr leer en un array de N elementos un elemento que se encuentra en una posición mayor que N:

int[] numerosPrimos = {1, 3, 5, 7, 9, 11, 13, 17, 19, 23}; // Array de diez elementos

int undecimoPrimo = numerosPrimos[10]; // Accedemos al undécimo elemento mediante el literal numérico 10

El código mostrado anteriormente accede a una posición inexistente dentro del array, y su ejecución lanzará la excepción unchecked ArrayIndexOutOfBoundsException (excepción de índice de array fuera del límite). Se puede observar que este es un error de programación, ya que el código tendría que haber comprobado el tamaño del array antes de intentar acceder a una posición concreta:

int[] numerosPrimos = {1, 3, 5, 7, 9, 11, 13, 17, 19, 23}; int indiceUndecimoPrimo = 10;

if(indiceUndecimoPrimo > numerosPrimos.length) { System.out.println("El índice proporcionado (" + indiceUndecimoPrimo + ") es mayor que el tamaño del array (" + numerosPrimos.length + ")"); } else { int undecimoPrimo = numerosPrimos[indiceUndecimoPrimo]; // ... }

Se pueden dar varios tipos de errores como por ejemplo:

Al tratar de acceder a elementos de arreglos con un índice mayor al del último elemento del arreglo.

Dividir para cero.

Manejo de archivos (archivos no existentes, no se cuentan con los permisos suficientes, etc.).

Errores accediendo a base de datos.

Errores definidos por el usuario (contraseñas incorrectas, números de tarjetas incorrectas, etc.).

Ejemplo:

Se creará un programa que divida dos números. Los números se introducirán en dos controles de edición. Se obtendrá el texto de cada uno de los controles de edición que se guardan en dos strings. En esta situación se pueden producir dos excepciones NumberFormatException, si se introducen caracteres no numéricos y ArithmeticException si se divide entre cero.

public class ExcepcionApp { public static void main(String[] args) { String str1="12";String str2="0";

String respuesta;int numerador, denominador, cociente;

try{ numerador=Integer.parseInt(str1); denominador=Integer.parseInt(str2); cociente=numerador/denominador; respuesta=String.valueOf(cociente); }catch(NumberFormatException ex){ respuesta="Se han introducido caracteres no numéricos"; }catch(ArithmeticException ex){ respuesta="División entre cero"; } System.out.println(respuesta); }

}

Como se puede apreciar las sentencias susceptibles de lanzar una excepción se sitúan en un bloque try..catch. Si el denominador es cero, se produce una excepción de la clase ArithmeticException en la expresión que se encuentra el cociente, que es inmediatamente capturada en el bloque catch que maneja dicha excepción, ejecutándose las setencias que hay en dicho bloque. En este caso se guarda el texto “División entre cero” en el string respuesta.

Para asegurarse de que siempre un archivo se cerrará después de que se produzca o no un error en el proceso de lectura/escritura se emplea el bloque finally.

try{//Este código puede generar una excepción

}catch(Exception ex){//Este código se ejecuta cuando se

produce una excepción}finally{

//Este código se ejecuta se produzca o no una excepción}

Cuando se produce una excepción, se crea un objeto de una de una determinada clase (según el error que se haya producido), que conservará la información sobre el error producido y proporcionará los métodos necesarios para obtener dicha información. Estas clases tienen como clase padre a la clase Throwable, por consiguiente se mantiene una jerarquía en las excepciones. A continuación se muestra la jerarquía de algunas de las muchas excepciones existentes:

Throwable: Clase base que constituye todo lo que se puede “lanzar” en Java.

Contiene una instantánea del estado de la pila en el momento preciso en el que se creó el objeto (“stack trace” o “call chain”).

Recopila un mensaje (variable de instancia de tipo String) que se puede utilizar para detallar el error producido.

Puede tener una causa, también de tipo Throwable que permite representar el error que causó este error.

Error: Subclase de Throwable que indica problemas graves que una aplicación no debería intentar solucionar.

Exception: La clase Exception y sus subclases muestran situaciones que una aplicación debería tratar de forma razonable.

Los dos tipos principales de excepciones son:

RuntimeException (errores del programador, como una división de por cero, etc.,).

IOException (errores que no puede evitar el programador, generalmente conexos con la entrada/salida del programa).

Ingrafía

http://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf

http://jarroba.com/excepciones-exception-en-java-con-ejemplos/

http://www.davidmarco.es/articulo/tratamiento-de-excepciones-en-java