MIGUEL ANGEL AGUILAR ESTANISLAO ES1511109383
UNIVERSIDAD ABIERTA Y A DISTANCIA DE MEXICO DESARROLLO DE SOFTWARE PROGRAMACIÓN ORIENTADA A OBJETOS 3ER SEMESTRE
UNIDAD 3 ACTIVIDAD 3
EXCEPCIONES En Java una excepción es un error o una condición anormal que se ha producido durante la ejecución de un programa. Java tiene diferentes tipos de excepciones: excepciones de I/O, las excepciones en tiempo de ejecución y las de su propia creación. Durante la compilación solamente se detectan los errores de sintaxis, pero el manejo de excepciones de Java permite el manipular los errores que ocurren en tiempo de ejecución, entre estas podemos mencionar las excepciones aritméticas (división entre cero), excepciones de puntero (acceso a punteros NULL) y excepciones de indexación (acceso por encima o debajo de los límites de un vector). Algunas excepciones son fatales y causan el fin de la ejecución del programa. En este caso conviene terminar ordenadamente y enviar un mensaje explicando el tipo de error que se ha producido. En otras situaciones, por ejemplo cuando no se encuentra un archivo sobre el que se desea realizar una operación, el programa puede dar al usuario la oportunidad de corregir el error. Un buen programa debe manejar correctamente la mayoría de los errores que se puedan producir, Java proporciona las siguientes herramientas para el manejo de excepciones: try, catch, throw, throws y finally. Jerarquía de las Excepciones En Java, todas las excepciones estan consideradas en el de árbol de excepciones que se deriva de la clase Throwable. Existen dos subclases directas de Throwable: Error y Exception. En la figura se observa parte de la jerarquía de clases derivada de Throwable:
La clase Error está relacionada con errores de la máquina virtual de Java y no el código, generalmente estos errores no dependen del programador por lo que no debe preocuparse por tratarlos. En la clase Exception se encuentran las excepciones RuntimeException, producidas por errores de programación. El compilador de Java obliga a corregirlas. Tipos de Excepciones En resumen las excepciones son generadas de tres formas diferentes. 1) La máquina Virtual de Java puede generar una excepción como producto de un error interno que está fuera de su control. Estas excepciones generalmente no pueden ser manejadas por el programa. 2) Excepciones estándar: Son excepciones que deben ser manipuladas, se producen cuando se ejecuta una división por cero o se trata de acceder a un arreglo con un índice fuera de límites son generadas por errores en el código del programa.
3) El programador puede generar una excepción manualmente utilizando la estructura throw. Sin importar cómo se produjo la excepción, se maneja de la misma forma.
Manejo de Excepciones Cuando se produce un error en un método, este crea un objeto 'exception' el cual contiene información sobre la excepción como el tipo de excepción y el estado del programa al presentarse el problema. El sistema de ejecución es el responsable de buscar algún bloque de código que maneje la excepción. En la terminología de java, al hecho de crear una objeto exception y manejarlo por el sistema de ejecución se le conoce como lanzar una excepción (throwing an exception). Bloque try/catch El núcleo del manejo de excepciones son los bloques try y catch. A continuación se muestra la forma general del manejo de bloques de excepción try/catch: try{ / código que pudiera ocasionar una excepción } catch (Tipo_de_Excepción1 Objeto_Excepcion){ código para manejar la excepción } catch (Tipo_de_Excepción2 Objeto_Excepcion){ código para manejar la excepción }
Cuando un segmento de código lanza una excepción, esta es atrapada por su correspondiente manejador catch. En un mismo bloque de instrucciones se puede generar más de una excepción, por lo que puede haber más de un bloque catch asociado a un solo try. La ejecución de catch no es como llamar a una función, es decir, después de ejecutar catch la ejecución del programa no regresa a donde se generó la excepción, sino que el flujo del programa continúa después del bloque catch. El siguiente programa genera una excepción al momento de su ejecución: public class PruebaExcepcion1{ public static void main(String args[]){ int numero[]=new int[5]; numero[7]=0; } }
La excepción generada es:
Agregando el código para el manejo de la excepción al mismo programa tenemos: public class PruebaExcepcionCorregida{ public static void main(String args[]){ int numero[]=new int[5]; try{ numero[7]=0; } catch(java.lang.ArrayIndexOutOfBoundsException Error){ System.out.println("Se genero una excepcion al acceder al arreglo"); } } } Ahora al producirse la excepción sigue las acciones especificadas en el bloque catch, es este caso, la acción consiste en mandar un mensaje. Excepción producida por un método y atrapada en otro. Una excepción puede ser generada en un método y atrapada por el método que llamó al primero, en el siguiente ejemplo, la excepción es generada en un método de una clase y es atrapada en el main de otra clase.
class GeneraExcepcion2{ void produceExcepcion(){ int numero[]=new int[5]; System.out.println("Tratando de acceder a una posicion fuera del vector"); numero[7]=0; } } public class PruebaGeneraExcepcion2{ public static void main (String args[]){ GeneraExcepcion2 objeto =new GeneraExcepcion2(); try{ objeto.produceExcepcion(); } catch (ArrayIndexOutOfBoundsException excep){ System.out.println("Excepcion Generada en otro bloque"); } } }
Excepción generada y atrapada en un método. Las excepciones no solamente son atrapadas en el método main, en el siguiente ejemplo la excepción es generada y capturada en un método invocado por main.
class GeneraExcepcion3{ void produceExcepcion(){ int numero[]=new int[5]; try{ System.out.println("Accesando a una posicion fuera del vector"); numero[7]=0; } catch (ArrayIndexOutOfBoundsException excep){ System.out.println("Ocurrio una excepcion"); } } } public class PruebaGeneraExcepcion3{ public static void main (String args[]){ GeneraExcepcion3 objeto =new GeneraExcepcion3(); objeto.produceExcepcion(); } }
En el ejemplo anterior dado que la excepción fue capturada por el método produceExcepcion(), el control del programa no podrá volver a main. Recuperación de la ejecución después de una excepción. Uno de los mayores beneficios del manejo de excepciones es el permitir a un programa responder a un error y luego continuar con la ejecución. Por ejemplo:
class ExcepcionContinua{ static void divide(){ int num[]={4,8,16,32,64,128,256}; int den[]={2,0,4,4,0,8,16}; for (int i=0;i
Claúsulas Catch Múltiples En un mismo segmento de código se pueden generar más de una excepción por diferentes motivos, por lo tanto un dicho segmento puede tener un bloque catch para cada excepción. class ExcepcionesMultiples{ static void divide(){ int num[]={4,8,16,32,64,128,256}; int den[]={2,0,4,4,0,8}; for (int i=0;i
Manejo de excepciones generales y específicas Una claúsula catch que atrapa a la superclase throwable atrapará a cualquier excepción. Si se requiere atrapar excepciones con un catch general y además hacer un catch para una excepción específica, entonces se debe colocar la subclase y después la clase Throwable. class ExcepcionGeneralyEspecifica{ public static void main(String args[]){ int num[]= {4,8,16,32,64,128,256,512}; int den[]= {2,0,4,4,0,8}; for (int i=0;i
}
Bloques try anidados Con frecuencia los bloques anidados try se usan para permitir diferentes niveles de errores, que serán manejados de diferentes formas. Algunos de estos errores son menores y pueden arreglarse fácilmente, pero otros son catastróficos y no se pueden corregir. Un método comúnmente empleado por los programadores es usar un bloque externo try para atrapar los errores graves y bloques internos try para el control de los errores sencillos. class ExcepcionesAnidadas { public static void main(String args[]){ int num[]= {4,8,16,32,64,128,256,512}; int den[]= {2,0,4,4,0,8}; try{ for (int i=0;i
Finally Muchas veces, cuando se produce una excepción es necesario un mecanismo que limpie el estado del método antes de que el control pase a otra parte del programa. Por ejemplo, una excepción podría causar un error que termine el método actual, pero tal vez antes sea necesario cerrar un archivo o una conexión a red. En Java esto se puede hacer esto encerrando el código de limpieza dentro de un bloque finally. El formato general de un try/catch que incluye finally es:
try{ código que produce la (s) excepción (es)... } catch( TipoDeExcepcion objeto){ // Código para manejar la excepción } finally{ // código de finally }
El bloque finally será ejecutado cada vez que se termine un bloque try/catch, sin importar como se salga del bloque try. class UseFinally{ public static void generaExcepcion(int i){ int t; int num[] = {2,4,6}; System.out.println("Recibiendo "+ what); try{ switch(i){ case 0: t=10/i; //division por cero break; case 1:num[4]=4; //genera un error break; case 2: return; } } catch(ArithmeticException exc){ System.out.println("No puede dividir entre cero"); return; // regresa desde catch } catch(ArrayIndexOutOfBoundsException exc) { System.out.println(" No hay elementos que coincidan"); } finally { System.out.println("Ejecutando codigo de limpieza"); } } //fin de metodo }//clase class PruebaUseFinally { public static void main(String args[]) { for (int i=0;i<4; i++) { UseFinally.generaExcepcion(i); System.out.println(); } } }
Throws En algunos casos, si un método genera una excepción que el programa no maneja, se debe declarar dicha excepción en la claúsula throws. La forma general de throws es: valorRetorno nombreMetodo (parámetros) throws excepción1, …., excepciónN{ //código del método } Las excepciones que derivan de Error o RuntimeException no necesitan ser especificados en una lista throws. Todos los otros tipos de excepciones necesitan ser declarados, o se producen errores en tiempo de compilación. Por ejemplo, en la entrada por teclado se puede generar una excepcion IOException, la cual no puede manejarse en el programa. class UseThrows{ static char prompt(String str) throws java.io.IOException{ System.out.println(str+ ": "); return (char) System.in.read(); } } public class PruebaUseThrows{ public static void main(String args[]){ char ch; try{ ch=UseThrows.prompt("Escriba una letra"); } catch( java.io.IOException exc){ System.out.println("Excepcion de entrada-Salida"); ch='X'; } } // main } //clase
Fuentes http://www.mundojava.net/excepciones.html?Pg=java_inicial_4_6.html http://codejavu.blogspot.mx/2013/05/interfaces-en-java.html http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=65 2:jerarquias-de-herencia-en-java-concepto-de-superclases-y-subclases-el-api-javaejemplos-cu00685b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188
