Lenguaje de Programación Java Manejo de excepciones

Manejo de excepciones Contenidos de la presentación: Jerarquía de excepciones Uso de try y catch Efectos de una excepción NO capturada Uso de varios catch Excepciones de subclases Anidar bloques try Lanzar una excepción Miembros de la clase Throwable Uso de finally Uso de throws Excepciones integradas de Java Crear clases personalizadas de excepciones

Conceptos básicos Una excepción es un “error” que ocurre en tiempo de ejecución. El manejo de excepciones mejora el manejo de errores al permitir que su programa defina un bloque de código llamado manejador de excepciones , que se ejecuta automáticamente cuando se produce un “error”. Java define excepciones estándar para errores comunes de programa, como la división por cero, archivo no encontrado.

Jerarquía de excepciones En java todas las excepciones están representadas por clases. Todas las clases de excepción se derivan de una clase llamada throwable. Cuando una excepción ocurre en un programa, se genera un objeto de alguna clase de excepción. Hay dos clases directas de throwable: Exception Error

Jerarquía de excepciones (cont.) Las excepciones de tipo Error están relacionados con errores que ocurren en la propia máquina virtual de Java y no en su programa. Los errores que resultan de la actividad propia del programa están representados por subclases de la clase exception. ( división por cero, limite de una matriz, manejo de archivos, etc. )

Fundamentos del manejo de excepciones El manejo de excepciones se maneja con: try catch throw throws Finally

Fundamentos del manejo de excepciones Las instrucciones que se desee monitorear deben estar contenidas en un bloque try. Si ocurre una excepción dentro del bloque try, se lanza. Para lanzar manualmente una excepción se debe utilizar throw. Las excepciones generadas por el sistema se lanzan automáticamente Una excepción que se lanza fuera de un método debe especificarse como tal, mediante la cláusula throws. Cualquier código que tenga que ejecutarse obligatoriamente una vez que se salga del bloque try, se colocará en el bloque finally

Uso de try y catch El eje del manejo de las excepciones se encuentra en try y catch. try { // bloque del código para monitorear errores } catch (TipoExcep1 exOb) { // manejador para Excep1 catch (TipoExcep2 exOb) { // manejador para Excep2 Obs: Si no se lanza una excepción, el bloque try terminará de manera normal y se omitirán las instrucciones del catch.

Ejemplo de try y catch Class ManejoExcepcion { public static void main ( String [ ]args) { int nums[ ] = new int [4]; try { System.out.println(“Mensaje antes que se genera la excepción”); // aquí se genera la excepción nums[12] = 87; // intento de indexar una posición inexistente System.out.println(“Este mensaje no se muestra”); }// del try catch ( ArrayIndexOutBoundsExcepction exc) { // Captura de la excepción System.out.println(“Indice fuera de rango … hasta aquí no mas llegamos”); }// del catch System.out.println (“tras la instrucción del catch… ”); }

Otro Ejemplo class ExcDemo{ static void genExec ( ) { int nums[ ] = new int [4]; System.out.println(“Antes que se genere la excepción”); //Genera una excepción de índice fuera de rango nums[12] = 23; System.out.println(“Este mensaje NO se muestra”); } }// de la clase class excDemo2 { public static void main ( String [ ]args ) { try { Excdemo.genExec(); catch (ArrayIndexOutOfBounds exc){ System.out.println(“Indice fuera del rango ..”); }// del main

Consecuencias de una excepción no capturada Si un programa no captura una excepción entonces está será capturada por la JVM. El problema es que el manejador de excepciones de la JVM termina con la ejecución de la aplicación y despliega una pila de mensajes de rastreo y error

Ejemplo // ejemplo donde JVM maneja el error class NoManejada { public static void main(String []args){ int nums[] = new int[4]; System.out.println(“Antes de que se genere el error”); // se genera la excepción nums[12] = 34; } El error que generará la JVM es: Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 7 at NoManejada.main(NoManejada.java:9)

¿por qué no funciona? Class NoFunciona{ public static void main ( String []args ) { int nums[ ] = new int [4]; try { nums[7] = 23; } catch (ArithmeticException exc){ System.out.println(“Indice fuera de rango”); Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 7 at NoManejada.main(NoManejada.java:9)

Manejo de errores Uno de los beneficios del manejo de excepciones es permitir al programa responder a errores y luego continuar ejecutándose.

class Ejemplo { public static void main( String []args){ int num[ ] = { 2 , 4 , 5 , 10 , 6 }; int den[ ] = { 1 , 0 , 5 , 0 , 2 }; for ( int i=0; i < num.length ; i++) try { System.out.println( num[i] + “ / ” + den[i] +” es : “ + num[i] / den[i] ); } catch (ArithmeticException exc) { System.out.println(“No se puede dividir por cero”); La salida del programa será: 2 / 1 es 2 No se puede dividir por cero 5 / 5 es 1 6 / 2 es 3

Uso de varios catch class EjemploVariosCatch { public static void main( String []args){ int num[ ] = { 2 , 4 , 5 , 10 , 6 }; int den[ ] = { 1 , 0 , 5 }; for ( int i=0; i < num.length ; i++) try { System.out.println( num[i] + “ / ” + den[i] +” es : “ + num[i] / den[i] ); } catch (ArithmeticException exc) { System.out.println(“No se puede dividir por cero”); } catch (ArrayIndexOutOfBoundsException exc) { System.out.println(“Falta numerador y/o denominador ”); } La salida del programa será: 2 / 1 es 2 No se puede dividir por cero 5 / 5 es 1 Falta numerador y/o denominador

Captura de excepciones de subclases Recuerde siempre que una cláusula catch de una superclase coincidirá también con cualquiera de sus subclases. Por lo que el orden en que se coloquen los catch es muy importante. //catch perteneciente a una subclass Catch (arrayIndexBoundsOfException ex) { System.out.println(“índice fuera de rango”); } //catch perteneciente a una superclass Catch (Throwable ex) { System.out.println(“Ocurrió alguna excepción”); }

Bloques try anidados Una excepción generada en un try interno que no es capturada por un catch asociado a ese try se propaga al boque try exterior. A menudo los bloques try anidados se usan para permitir manejar de distintas maneras las diferentes categorías de errores. Es común que programadores usen el bloque try externo para capturar los errores más graves , permitiendo que los bloques try internos manejen los menos serios.

class EjemploTryAnidado { public static void main( String []args){ int num[ ] = { 2 , 4 , 5 , 10 , 6 }; int den[ ] = { 1 , 0 , 5 }; try { // try externo for ( int i=0; i < num.length ; i++) { try { // try interno System.out.println( num[i] + “ / ” + den[i] +” es : “ + num[i] / den[i] ); } catch (ArithmeticException exc) { System.out.println(“No se puede dividir por cero”); } // del for catch (ArrayIndexOutOfBoundsException exc) { System.out.println(“No existen elementos coincidentes”); System.out.printn(“Error Fatal: Aplicación finalizada”); La salida del programa será: 2 / 1 es 2 No se puede dividir por cero 5 / 5 es 1 No existen elementos coincidentes Error Fatal: Aplicación finalizada

Lanzamiento de una excepción Lenguaje Java permite lanzar manualmente una excepción con el uso de la instrucción throw. throw excepOb; En donde execpOb, debe ser un objeto de una clase derivada de throwable

// Lanzamiento manual de una excepción class ThrowManual { public static void main( String []args){ try { System.out.println(“Antes del lanzamiento de la excepción ..”) throw new ArithmeticException } catch (ArithmeticException exc) { System.out.println(“ La excepción ha sido capturada con éxito”); La salida del programa será: Antes del lanzamiento de la excepción.. La excepción ha sido capturada con éxito

Relanzamiento de una excepción Una excepción capturada por una instrucción catch puede relanzarse para que la pueda capturar un catch externo. La razón más común para utilizar relanzamiento es permitir que varios manejadores accedan a la excepción. Cuando se relanza una excepción, ésta no será recapturada por la misma instrucción catch, sino que se propagará a la siguiente instrucción catch.

class Rethrow{ public static void genExc( ){ int num[ ] = { 2 , 4 , 5 , 10 , 6 }; int den[ ] = { 1 , 0 , 5 }; for ( int i=0; i < num.length ; i++) { try { System.out.println( num[i] + “ / ” + den[i] +” es : “ + num[i] / den[i] ); } catch (ArithmeticException exc) { System.out.println(“No se puede dividir por cero”); } catch (ArrayIndexOutOfBoundsException exc) { System.out.println(“No existen elementos coincidentes”); throw exc; } class rethrowDemo { public static void main ( String [ ]args ) { Rethrow.genExc ( ); System.out.println(“Error Fatal: Aplicación finalizada”); }

Finally Se suele utilizar finally cuando se desee definir un bloque de código que se ejecute cuando se deje un bloque try/catch. El bloque de finally se ejecutará cada vez que la ejecución deje el bloque try/catch sin importar la condición que la origine. Es decir, si el bloque try termina de manera normal, o debido a una excepción, el último código ejecutado estará definido por finally. Finally podría ser útil por ejemplo, si una excepción genera un error que termine el método actual. Sin embargo, ese método podría tener abierto un archivo o una conexión de red los que necesiten ser cerrados.

Formato de finally try { // bloque de código para monitorear errores } catch ( TipoExcep1 exOb) { //manejador para TipoExcep1 catch ( TipoExcep2 exOb) { //manejador para TipoExcep2 finally { // codigo de finally

Uso de throws Si un método genera una excepción que no se maneja, debe declarar esa excepción en una cláusula throws. TipoRet nombreMet(params) throws lista-excepción { // cuerpo del método } En donde: Lista-excepción es una lista de excepciones separadas por comas que el mismo método podría lanzar fuera de sí mismo. Las excepciones que son subclases de Error y RuntimeException no necesitan especificarse en una lista de throws.

Class ThrowsDemo { public static char aviso( String cad) throws java Class ThrowsDemo { public static char aviso( String cad) throws java.io.IOException { System.out.print(cad+”:”); return (char) System.in.read(); } public static void main ( String []args) { char ch; try { ch = aviso(“Escriba una letra”); catch (java.io.IOException exc){ System.out.println(“Ocurrió una excepción de E/S” ); System.out.println(“Usted presionó :”+ch);

Excepción (RunTimeException) significado ArithmeticException Error aritmético ( división por cero ) ArrayIndexOutOfBoundsException Índice fuera del rango de una matriz ArrayStoreException Asignación a una matriz de tipo incompatible ClassCastException Moldeo de clase no válido IllegalArgumentException Argumento ilegal para invocar un método IllegalMonitorStateException Operación ilegal de monitoreo IllegalStateException La aplicación está en un estado incorrecto IllegalThreadStateException La operación solicitada no es compatible con el estado del subproceso IndexOutBoundOfException Algún tipo de índice esta fuera de los límites NegativeArraySizeException Matriz creada con un tamaño negativo NullPointerException Uso no válido de una referencia a null NumberFormatException Conversión no válida ( cadena a número) SecurityException Intento de violar seguridad StringIndexOutBounds Intento de indizar fuera de los límites del string TypeNotPresentException Tipo no encontrado ( a partir de versión j2se 5 ) UnsupportedOperationException Operación no permitida

Exception Significado ClassNotFoundException No se encuentra la clase CloneNotSupportedException Intento de clonar un objeto que no implementa la interfaz clonable IllelgalAccessException Se niega el acceso a una clase InstantiationException Intento de crear un objeto de una clase o una interfaz abstracta InterruptedException Un subproceso ha interrumpido a otro NoSuchFieldException No existe un campo solicitado NoSuchMethodException No existe un método solicitado

Creación de subclases de excepción Aunque las excepciones integradas de Java manejan lo errores más comunes, no se está limitado sólo a éstos errores. Para poder crear nuestra propia excepción: Debe definir una subclase de Exception La clase exception no define métodos por si misma. No obstante hereda los métodos proporcionados por Throwable. Por lo tanto puede sobrescribir uno o más de los métodos de las subclases de excepción que usted cree.

Creación de una excepción class NonIntResultException extends Exception{ int numerador; int denominador; NonIntResultException ( int i , int j){ numerador = i; denominador = j; } public String toString( ) { return “El resultado de ” + numerador + ”/” + denominador + ”no es un entero”);

class ExcPersonalDemo { public static void main ( String args[ ] ) { int nums[ ] = { 4 , 8 , 15 }; int den[ ] = { 2 , 0 , 4 }; for ( int i=0 ; i < nums.length; i++) try { if ( ( nums[i] % 2 ) != 0 ) throw new NonIntResultException(num[i] , den[i] ); System.out.println(nums[i]+”/”+den[i] +” es “+ nums[i] / den[i]); } catch (ArithmeticException exc ){ System.out.println(“No se puede dividir por cero ..”); } catch (ArrayIndexOutOfBoundsExcetion exc ){ System.out.println(“Índice fuera de rango ..”); } catch (NonIntResultException exc ){ System.out.println( exc ); } } } Salida que produce: 4 / 2 es 2 No se puede dividir por cero.. El resultado de dividir 15 / 4 no es un entero

Clase Throwable Método Descripción Throwable fillnStackTrace() Retorna un objeto Throwable que contiene un rastreo de pila completo String getLocalizedMessage() Retorna una descripción localizada de la excepción String getMessage() Regresa una descripción de la excepción Void printStackTrace() Despliega el rastreo de la pila Void printStackTrace(printStream flujo) Envía el rastreo de la pila al flujo especificado Void printStacktrace(PrintWriter flujo) String toString() Retorna un objeto String que contiene una descripción de la excepción