Lenguaje de Programacin Java MANEJO DE EXCEPCIONES Manejo

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 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 (Tipo. Excep 1 ex. Ob) { // manejador para Excep 1 } catch (Tipo. Excep 2 ex. Ob) { // manejador para Excep 2 } 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 Manejo. Excepcion { 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 ( Array. Index. Out. Bounds. Excepction 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 Exc. Demo{ static void gen. Exec ( ) { 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 exc. Demo 2 { public static void main ( String [ ]args ) { try { Excdemo. gen. Exec(); } catch (Array. Index. Out. Of. Bounds exc){ System. out. println(“Indice fuera del rango. . ”); } }// del main }// de la clase

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 No. Manejada { 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. Array. Index. Out. Of. Bounds. Exception: 7 at No. Manejada. main(No. Manejada. java: 9)

¿por qué no funciona? Class No. Funciona{ public static void main ( String []args ) { int nums[ ] = new int [4]; try { nums[7] = 23; } catch (Arithmetic. Exception exc){ System. out. println(“Indice fuera de rango”); } } Exception in thread “main” java. lang. Array. Index. Out. Of. Bounds. Exception: 7 at No. Manejada. main(No. Manejada. 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 (Arithmetic. Exception 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 No se puede dividir por cero 6 / 2 es 3

Uso de varios catch class Ejemplo. Varios. Catch { 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 (Arithmetic. Exception exc) { System. out. println(“No se puede dividir por cero”); } catch (Array. Index. Out. Of. Bounds. Exception 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 (array. Index. Bounds. Of. Exception 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 Ejemplo. Try. Anidado { 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 (Arithmetic. Exception exc) { System. out. println(“No se puede dividir por cero”); } } // del for catch (Array. Index. Out. Of. Bounds. Exception 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 excep. Ob; En donde execp. Ob, debe ser un objeto de una clase derivada de throwable

// Lanzamiento manual de una excepción class Throw. Manual { public static void main( String []args){ try { System. out. println(“Antes del lanzamiento de la excepción. . ”) throw new Arithmetic. Exception } catch (Arithmetic. Exception 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 gen. Exc( ){ 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 (Arithmetic. Exception exc) { System. out. println(“No se puede dividir por cero”); } catch (Array. Index. Out. Of. Bounds. Exception exc) { System. out. println(“No existen elementos coincidentes”); throw exc; } } class rethrow. Demo { public static void main ( String [ ]args ) { try { Rethrow. gen. Exc ( ); } catch (Array. Index. Out. Of. Bounds. Exception exc) { 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 ( Tipo. Excep 1 ex. Ob) { //manejador para Tipo. Excep 1 } catch ( Tipo. Excep 2 ex. Ob) { //manejador para Tipo. Excep 2 } 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. Tipo. Ret nombre. Met(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 Runtime. Exception no necesitan especificarse en una lista de throws.

Class Throws. Demo { 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 (Run. Time. Exception) significado Arithmetic. Exception Error aritmético ( división por cero ) Array. Index. Out. Of. Bounds. Exception Índice fuera del rango de una matriz Array. Store. Exception Asignación a una matriz de tipo incompatible Class. Cast. Exception Moldeo de clase no válido Illegal. Argument. Exception Argumento ilegal para invocar un método Illegal. Monitor. State. Exception Operación ilegal de monitoreo Illegal. State. Exception La aplicación está en un estado incorrecto Illegal. Thread. State. Exception La operación solicitada no es compatible con el estado del subproceso Index. Out. Bound. Of. Exception Algún tipo de índice esta fuera de los límites Negative. Array. Size. Exception Matriz creada con un tamaño negativo Null. Pointer. Exception Uso no válido de una referencia a null Number. Format. Exception Conversión no válida ( cadena a número) Security. Exception Intento de violar seguridad String. Index. Out. Bounds Intento de indizar fuera de los límites del string Type. Not. Present. Exception Tipo no encontrado ( a partir de versión j 2 se 5 ) Unsupported. Operation. Exception Operación no permitida

Exception Significado Class. Not. Found. Exception No se encuentra la clase Clone. Not. Supported. Exception Intento de clonar un objeto que no implementa la interfaz clonable Illelgal. Access. Exception Se niega el acceso a una clase Instantiation. Exception Intento de crear un objeto de una clase o una interfaz abstracta Interrupted. Exception Un subproceso ha interrumpido a otro No. Such. Field. Exception No existe un campo solicitado No. Such. Method. Exception 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 Non. Int. Result. Exception extends Exception{ int numerador; int denominador; Non. Int. Result. Exception ( int i , int j){ numerador = i; denominador = j; } public String to. String( ) { return “El resultado de ” + numerador + ”/” + denominador + ”no es un entero”); } }

class Exc. Personal. Demo { 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 Non. Int. Result. Exception(num[i] , den[i] ); System. out. println(nums[i]+”/”+den[i] +” es “+ nums[i] / den[i]); } catch (Arithmetic. Exception exc ){ System. out. println(“No se puede dividir por cero. . ”); } catch (Array. Index. Out. Of. Bounds. Excetion exc ){ System. out. println(“Índice fuera de rango. . ”); } catch (Non. Int. Result. Exception 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 filln. Stack. Trace() Retorna un objeto Throwable que contiene un rastreo de pila completo String get. Localized. Message() Retorna una descripción localizada de la excepción String get. Message() Regresa una descripción de la excepción Void print. Stack. Trace() Despliega el rastreo de la pila Void print. Stack. Trace(print. Stream flujo) Envía el rastreo de la pila al flujo especificado Void print. Stacktrace(Print. Writer flujo) Envía el rastreo de la pila al flujo especificado String to. String() Retorna un objeto String que contiene una descripción de la excepción