Unidad 5 “Excepciones”

En esta unidad hablaremos del manejo de excepciones. Una excepción es la indicación de un problema que ocurre durante la ejecución de un programa. El nombre “excepción” viene del hecho de que, aunque puede ocurrir un problema, éste ocurre con poca frecuencia; si la “regla” es que una instrucción generalmente se ejecuta en forma correcta, entonces la “excepción a la regla” es cuando ocurre un problema.

Definición. Consiste en prevenir errores lógicos en la ejecución de las instrucciones de un programa, haciendo entender como si no hubiera pasado nada en su ejecución.

El manejo de excepciones permite a los programadores crear aplicaciones que puedan resolver (o manejar) las excepciones. En muchos casos, el manejo de una excepción permite que el programa continúe su ejecución como si no se hubiera encontrado del problema. Un problema más grave podría evitar que un programa continuara su ejecución normal, en vez de requerir al programa que notifique al usuario sobre el problema antes de terminar de manera controlada.

Qué son las excepciones. Son sentencias condicionales parecidos al if… else, (llamados try… catch() ) que permite invocar a ciertas clases que están calibradas para resolver problemas de ciertos casos lógicos que ocurren en la ejecución de un programa.

La lógica del programa evalúa frecuentemente condiciones que determinan cómo debe procesar la ejecución del programa. Considerando el siguiente pseudocódigo:

Realizar un atareaSi la tarea anterior no se ejecutó correctamente

Realizar el procesamiento de erroresRealizar la siguiente tarea

Si la tarea anterior no se ejecutó correctamente Realizar el procesamiento de errores

En este pseudocódigo empezamos realizando una tarea; después, evaluamos si esa tarea se ejecutó correctamente. Si no lo hizo, realizamos el procesamiento de los errores.

De esta manera, continuamos con la siguiente tarea. Aunque esta forma de manejo de errores funciona, al entremezclar la lógica del programa con la lógica del manejo de errores el programa podría ser difícil de leer, mantener y depurar; especialmente en aplicaciones extensas.

El manejo de excepciones está diseñado para procesar errores sincrónicos, que ocurre cuando se ejecuta una instrucción. Ejemplos comunes son los índices fuera de rango, el desbordamiento aritmético (es decir, un valor fuera de rango representable de valores), la división entre cero, los parámetros inválidos de métodos, la interrupción de subprocesos y la asignación fallida de memoria (debido a la falta de ésta).

El manejo de excepciones no está diseñado para procesar los problemas asociados con los eventos asíncronos (por ejemplo, completar las operaciones de E/S de disco, la llegada de

mensajes de red, clics del ratón y pulsaciones de teclas), los cuales ocurren en paralelo con, y en forma independiente de, el flujo de control del programa.

Con lenguajes de programación que no soporta el manejo de excepciones, los programadores a menudo retrasan la escritura de códigos de procesamiento de errores, o algunas veces olvidan incluirlo. Esto hace que los productos sean menos robustos. Java permite al programador tratar con el manejo de excepciones fácilmente, desde el comienzo de un proyecto. Sin embargo, el programador debe incorporar una estrategia de manejo de excepciones en los proyectos de software.

El mecanismo de manejo de excepciones también es útil para procesar los problemas que ocurren cuando un programa invoca a los métodos de otras clases. En vez de manejar los problemas internamente, dichos métodos utilizan por lo común excepciones para notificar a los métodos que hacen las llamadas cuándo ocurren los problemas. Esto permite a los programadores implementar un manejo de errores personalizados para cada aplicación.

El manejo de excepciones está dirigido a situaciones en las que el método que detecta un problema es incapaz de manejarlo. Dicho método lanza una excepción. No hay garantía que habrá un manejador de excepciones (código que se ejecuta cuando el programa detecta una excepción) para procesar ese tipo de excepción. Si existe, el manejador de excepciones atrapa y maneja a esa excepción. El resultado de una excepción no atrapada a menudo produce efectos adversos y podría terminar con la ejecución del programa.

Java proporciona las instrucciones try para permitir el manejo de excepciones. Una instrucción try consiste de la palabra clave try, seguida por llaves ( { } )que delimitan a ese bloque try. El bloque try contiene instrucciones que podrían ocasionar excepciones, e instrucciones que no deberían ejecutarse en caso de que ocurra una instrucción. Debe haber por lo menos una cláusula catch (a la que también se le llama manejador de excepciones) o una cláusula finally inmediatamente después del bloque try.

Cada clausula catch especifica entre paréntesis un parámetro de excepción, el cual identifica el tipo de excepción que puede procesar el manejador. El nombre del parámetro de excepción permite a la cláusula catch interactúe con un objeto de excepción atrapada. Después del último manejador catch, una cláusula finally opcional proporciona código que siempre se ejecuta. Sin importar que ocurra o no un excepción.

El punto en el programa en el que ocurre una excepción ( es decir, la ubicación en la que un método detecta y lanza una excepción) se conoce como el punto de lanzamiento. Si ocurre una excepción en un bloque try, ese bloque termina inmediatamente y el control del programa se transfiere a la primera cláusula catch que vaya después del bloque try. Esto se conoce como modelo de terminación del manejo de excepciones, ya que el bloque try que encierra una excepción lanzada termina al ocurrir esa excepción.

Si no ocurre excepciones en un bloque try, el programa ignora el (los) manejador(es) para ese bloque. La ejecución del programa continúa con la siguiente instrucción que haya

después de la secuencia try/catch. Si aparece una cláusula finally después de la última cláusula catch, la cláusula finally se ejecutará sin importa que ocurra o no una excepción. Si ocurre una excepción en un método y no es atrapada, o si la instrucción que produjo la excepción no se encuentra dentro de un bloque try, el método que contiene la instrucción termina inmediatamente y el programa trata de localizar un bloque try circundante en el método que hizo la llamada. (Y ese proceso, se le conoce como limpieza de la pila, que se describe más adelante).

Además, en los ejemplos que hemos estado utilizando en las unidades anteriores, en los que se leyeron valores numéricos del usuario, se suponía que este escribiría un valor entero apropiado. Sin embargo, los usuarios algunas veces cometen errores e introducen valores no enteros. Si el método parseInt de la clase Integer recibe una cadena que no representa a un entero valido, el método lanza una excepción NumberFormatException. Por lo tanto, este programa demuestra también cómo atrapar excepciones NumberFormatException.

// un ejemplo de manejo de excepciones que comprueba la division entre cero.

import javax.swing.JOptionPane; class DivisionEntreCero { // demuestra como lanzar una excepcio cuando ocurre uan división entre cero public int Cociente (int numerador, int denominador) throws ArithmeticException {return numerador / denominador;}

public int LeerValor(){ String Cad=""; int valor=0;

Cad = JOptionPane.showInputDialog(null,"digite un valor numerico ");valor = Integer.parseInt(Cad);

return valor;}

public void CalcularDivision(){ int numerador=0, denominador=0, Resultado=0; try { numerador = LeerValor(); denominador = LeerValor();

Resultado = Cociente(numerador, denominador); JOptionPane.showMessageDialog(null,"el cociente es "+Resultado);

} // procesar o prevenir la entrad con formato incorrecto catch(NumberFormatException Objeto) { JOptionPane.showMessageDialog(null,"Digite dos numeros","Formato de numero invalido",JOptionPane.INFORMATION_MESSAGE); //procesar o prevenir los intentos de dividir entre cero catch(ArithmeticException Objeto) {JOptionPane.showMessageDialog(null,Objeto.toString(),"Excepcion Aritmética", JOptionPane.INFORMATION_MESSAGE); } } //fin del metodo public static void main(String[] vars) { DivisionEntreCero Obj = new DivisionEntreCero(); Obj.CalcularDivision(); }} // fin de la clase

Jerarquía de Excepciones

En este aparatado examinaremos la jerarquía de herencia de las excepciones en Java. Las excepciones, al igual que casi todo lo demás en Java, son objetos. Por lo tanto, los programadores pueden crear jerarquías de clases de excepciones. En figura #1 se muestra una pequeña porción de la jerarquía de herencia para la clase Throwable (una subclase de Object), la cual es la superclase de todas las excepciones.

Sólo pueden usarse objetos Throwable con el mecanismo de manejo de excepciones. La clase Throwable tiene dos subclase: Exception y Error. La clase Excepction y sus subclases (por ejemplo, RuntimeException e IOException, ambas del paquete java.lang) presentan situaciones excepcionales que podría ocurrir en un programa de Java, y que podría ser atrapadas por la aplicación. La clase Error y sus subclases (por ejemplo, OutOfMemoryError) presentan situaciones excepcionales que podría ocurrir en el sistema en tiempo de ejecución en java, pero que generalmente no deben ser atrapadas por una aplicación.

Volver a Lanzar una Excepción

Es posible que una cláusula catch, después de recibir una excepción, decida que no puede procesar esa excepción o que sólo puede procesarla parcialmente. En tales casos, la cláusula catch puede diferir el tiempo de la excepción (o tal vez una porción de la misma) hacia otra cláusula catch. En cualquier caso, el manejador logra esto volviendo a lanzar una excepción, mediante la instrucción:

Throw referenciaExcepcion;

Figura #1 “Jerarquía de herencia para la clase Throwable”

OutOfMemoryerrorAWTErrorIOExceptionRuntimeException

ErrorException

Throwable

En donde referenciaExcepcion es el nombre del parámetro para la excepción en el manejador catch. Cuando se vuelve a lanzar la excepción, el siguiente bloque try circundante detecta la excepción que se volvió a lanzar, que el manejador catch que aparece después de ese bloque try circundante intenta manejar.

Cláusula finally

Los programas que obtienen ciertos tipos de recursos deben devolver esos recursos al sistema en forma explícita, para evitar las denominadas fugas de recursos. En Lenguajes de programación como C y C++, el tipo común de fuga de recursos es la fuga de memoria. Java realiza la recolección automática de basura en la memoria que ya no es utilizada por los programas, evitando así la mayoría de la fugas de memoria. Sin embargo, pueden ocurrir otros tipos de fugas de recurso en Java. Por ejemplo, los archivos las conexiones de bases de datos y conexiones de red que no se cierran apropiadamente podrían no estar disponibles para su uso en otros programas, o incluso más tarde en la ejecución del mismo programa.

La cláusula finally es opcional. Si está presente, se coloca después de la última cláusula catch, como se muestra en el siguiente pseudocódigo

java garantiza que la cláusula finally (si hay una presente después de una secuencia de try/catch) se ejecutará se lance o no una excepción en el bloque try correspondiente, o en cualquiera de sus cláusulas catch correspondientes.

Java garantiza también que una cláusula finally (si hay una presente) se ejecutará si un bloque try se sale mediante el uso de una instrucción return, break o continue.

El código para liberar recursos generalmente se coloca en la cláusula finally. Suponga que se asigna un recurso en un bloque try. Si no ocurre una excepción, se ignoran los manejadores catch y el control procede a la cláusula finally, la cual libera el recurso. El control del programa continua con la primera instrucción que se sigue después de la cláusula finally. Si ocurre una excepción, el programa ignora el resto del bloque try.

try { Instrucciones, Instrucciones para adquirir recursos }catch(UnTipoDeExcepcion ObjetoExcepcion) { Instrucciones para manejar excepciones }catch(OtroTipoDeExcepcion ObjetoExcepcion) { Instrucciones para manejar excepciones }finally {instrucciones, Instrucciones para manejar excepciones }

Si el programa atrapa la excepción en uno de los manejadores catch, el programa procesa la excepción. Después, la cláusula finally libera el recurso y el control procede a la primera instrucción después de la cláusula finally.

Limpieza de la pila

Cuando se lanza una excepción, pero no se atrapa en un alcance específico, la pila de llamadas a métodos se limpia y se hace un intento de atrapar (catch) la excepción en la siguiente instrucción try/catch exterior.

// Demostración del mecanismo try-catch-finally para manejo de excepcionespublic class UsoExcepcion{ public static void main(String[] vars)

{ try {LanzarExcepcion();} //llama al método LanzarExcepcion // atrapar excepciones lanzadas por el metodo LanzaExcepcion

catch(Exception ObjExcepcion) { System.out.println("La excepcion se manejo en main.."); } NoLanzarExcepcion();}

public static void LanzarExcepcion() throws Exception{ // lanzar una excepcion y atraparla inmediantamente try{System.out.println("El metodo Lanzar Excepcion..");

throw new Exception(); } // genera excepcion catch(Exception ObjExcepcion) {System.out.println("La excepcion se manejo en el metodo

LanzarExcepcion.."); throw ObjExcepcion; // volver a lanzar para procesarla posteriormente

// cualquier código aquí no llegaría a ejecutarse}

// este bloque se ejecuta, sin importar lo que ocurra en try/catchfinally { System.out.println("Finalmente se ejecuto en LanzarExcepcion.."); }

// cualquier código aquí no llegaría a ejecutarse}

// demostrar finally cuando no ocurre excepción public static void NoLanzarExcepcion() {// el bloque try no lanza una excepcion try { System.out.println("El metodo NoLanzarExcepcion...."); } catch(Exception ObjExcepcion) { System.out.println(ObjExcepcion);}

// la cláusula this se ejecuta, sin importar lo que ocurre en try/catch finally { System.out.println("Finalmente se ejecutó en NoLanzarExcepcion..."); }

System.out.println("Fin del metodo NoLanzarExcepcion "); } // fin del metodo NoiLanzarExcepcion} //Fin de la clase UsoExcepcion

Limpiar la pila de llamadas a métodos significa que el método en el que no se atrapó la excepción termina, todas la variables en ese método quedan fuera de alcance y el control regresa a la instrucción que invocó originalmente a ese método. Si un bloque try encierra a esa instrucción, se hace un intento de atrapar (catch) esa excepción. Si un bloque try no encierra a esa instrucción, se lleva a cabo la limpieza de la pila otra vez. Si ningún manejador catch atrapa a esta excepción, todo el programa (o una parte del mismo) terminará. El siguiente ejemplo en código nos muestra una aplicación de limpieza de la pila.

// Demostración de la limpieza de la pilapublic class UsoExcepciones{ public static void main(String[] vars)

{ try //llamar a LanzarExcepcion para demostrar la limpieza de la pila {LanzarExcepcion();} // atrapar excepcion lanzada en LanzarExcepcion

catch(Exception ObjExcepcion){ System.out.println("La excepcion se manejo en main.."); }

} //fin del método main

//LanzarExcepcion lanza la excepcion que no es atrapada en este metodopublic static void LanzarExcepcion() throws Exception{

// lanzar una excepcion y atraparla en maintry{System.out.println("El metodo LanzarExcepcion.."); throw new Exception(); } // genera excepcion //catch es del tipo incorrecto, por lo que la excepcion no es atrapada catch(RuntimeException ObjTiempoEjecucio){ System.out.println("La excepcion se manejo en el metodo LanzarExcepcion.."); }

// la clausula finally siempres se ejecutafinally { System.out.println("Finalmente siempre se ejecuto.."); }

} // fin del metodo} //Fin de la clase UsoExcepcion