Resumen Manejo de Excepciones Excepción Excepción es un cierto tipo de error o una condición anormal que se ha producido durante la ejecución de un programa. El nombre de excepción viene del hecho de que, es un problema que ocurre con poca frecuencia; si la regla es que una instrucción se ejecuta de forma correcta, entonces la excepción a la regla es cuando ocurre un problema. En Java una excepción es un objeto que avisa que ha ocurrido un cierto tipo de error o una condición anormal durante la ejecución de un programa. Java dispone de una jerarquía de clases que permiten crear objetos de excepciones. Fuente: Aprenda Java como si estuviera en Primero. Universidad de Navarra. 1999 La clase Error está relacionada con errores de compilación, del sistema o de la JVM (Java Virtual Machine). La clase Exception es la superclase de todas las excepciones que se presentan en los programas en tiempo de ejecución. Manejo de excepciones El manejo de excepciones permite a los programadores crear p r o g r a m a s r o b u s t o s y t o l e r a n t e s a f a l l a s, que lanzan o manejan 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 el problema. Los errores relacionados con errores de compilación, del sistema o de la JVM, s o n i r r e c u p e r a b l e s y no dependen del programador ni debe preocuparse de capturarlos y tratarlos. El manejo de excepciones está diseñado para procesar errores que ocurren cuando se ejecuta una instrucción. Las excepciones en tiempo de ejecución ocurren cuando el programador no ha tenido
2 cuidado al escribir su código. Por ejemplo, cuando se sobrepasa la dimensión de un arreglo se lanza una excepción ArrayIndexOutOfBounds. Cuando se hace uso de una referencia a un objeto que no ha sido creado se lanza la excepción NullPointerException. Estas excepciones le indican al programador que tipos de fallos tiene el programa y que debe arreglarlo antes de proseguir. Java permite lanzar o manejar las excepciones. Lanzar una excepción En Java puede considerarse una excepción como un segundo tipo de valor que puede devolver un método en caso de que exista una situación anormal durante la ejecución del método. Para lanzar una excepción, un método debe crear un objeto de la clase Exception o de alguna subclase de Exception y utilizar la instrucción throw (la instrucción throw es parecida a la instrucción return). Además debe especificar en la cabecera del método, que puede lanzar la excepción usando la instrucción throws. El siguiente código muestra como crear y lanzar un objeto Exception cuando el método dividir trata de dividir por cero. Avisa que puede lanzar una excepción public static int dividir(int num, int den) throws Exception{ if (den == 0) throw new Exception( División por cero ); else return num/den; Lanza una excepción En vista de que el método dividir puede lanzar una excepción, cualquier método que lo llame a él d e b e lanzar o capturar la excepción lanzada por el método dividir. Similar a un juego de beisbol (baseball), un jugador lanza la pelota y el que la recibe la captura o la lanza de nuevo. Otro ejemplo de un método que lanza una excepción es el método parseint de la clase Integer: public static int parseint(string s)throws NumberFormatException
3 Capturar una excepción Para capturar una excepción Java proporciona el bloque: //aquí se coloca el código del programa que puede producir una excepción catch(exception obj){ Se declara un objeto del tipo de la clase de Excepción que se está capturando //aquí se coloca el código que el programa debe ejecutar cuando capture la excepción finally{ /* aquí se coloca el código que el programa debe ejecutar ocurra o no ocurra la excepción por ejemplo, cerrar un archivo */ El siguiente código muestra como el método dividir captura la excepción que puede ser lanzada por el método dividir. /**En caso de que el método dividir lance una excepción * de división por cero, el método dividirvector * la captura y la maneja, NO la lanza */ public void dividirvector(double x[], int y[]){ int i = 0; for(;i < x.length; i++) x[i] = dividir(x[i], y[i]); catch (Exception obj){ System.out.println("getMessage = "+ obj.getmessage()+ "\ntostring = " + obj); System.out.println("Traza del stack = ");obj.printstacktrace(); System.out.println("Error en la posición i= "+i); Nota: si dentro de un bloque se producen varios tipos de excepciones, se puede colocar un catch para cada una o colocar un solo catch y recibir un objeto de la clase Exception que es la superclase de todas las excepciones.
4 Para visualizar como Java maneja el lanzamiento y captura de excepciones usaremos la clase ManejoExcepciones y dos Java main class PruebaLanzandoExcepciones y Prueba CapturandoExcepciones. /* * ManejoExcepciones.java * Created on 17 de mayo de 2006, 11:05 AM * autor M. Fátima De Abreu */ package CompAvanz12006.Unidad2.excepciones; public class ManejoExcepciones { public ManejoExcepciones() { /** método que divide a/b sin verificar * que b sea diferente de cero*/ public double dividir(int a, int b) { return (double)a/b; /** método que lanza una excepción * cuando ocurre la division por cero*/ public double dividir(double a, int b) throws Exception{ if (b == 0) throw new Exception("División por cero"); else return a/b; /** En caso de que el método dividir lance una excepción * de división por cero, el método dividirvector se la lanza * al método que lo llamó */ public void dividirvector(double x[], int a)throws Exception{ for(int i = 0; i < x.length; i++) x[i] = dividir(x[i], a); /**En caso de que el método dividir lance una excepción * de división por cero, el método dividirvector * la captura y la maneja, NO la lanza */
5 public void dividirvector(double x[], int y[]){ int i = 0; for(;i < x.length; i++) x[i] = dividir(x[i], y[i]); catch (Exception obj){ System.out.println("getMessage = "+ obj.getmessage()+ "\ntostring = " + obj); System.out.println("Traza del stack = ");obj.printstacktrace(); System.out.println("Error en la posición i= "+i); public class PruebaLanzandoExcepciones { public PruebaLanzandoExcepciones() { El método main lanza cualquier excepción que le lancen a el public static void main(string[] args) throws Exception { ManejoExcepciones obj = new ManejoExcepciones(); System.out.println("division 4/0 = " + obj.dividir(4,0)); System.out.println("division 4.0/0 = " + obj.dividir(4.0,0)); double x[]={1,2,3,4; int y[] = {1,2,0,4; System.out.println("\nProbando con los vectores\n"); obj.dividirvector(x,y); obj.dividirvector(x,0); System.out.println("\nProbando con los vectores 66666666666666\n");
6 public class PruebaCapturandoExcepciones { public PruebaCapturandoExcepciones() { public static void main(string[] args) { ManejoExcepciones obj = new ManejoExcepciones(); System.out.println("division 4/0 = " + obj.dividir(4,0)); System.out.println("division 4.0/0 = " + obj.dividir(4.0,0)); System.out.println("\nProbando con los vectores\n"); double x[]={1,2,3,4; int y[] = {1,2; obj.dividirvector(x,y); obj.dividirvector(x,0); main captura y maneja cualquier excepción que reciba catch(exception obj){ System.out.println("Exceptio\n"+obj); Java tiene muchos objetos de excepción predefinidos, y también podemos crear los nuestros propios. Crear nuevas clases de Excepciones El programador puede crear sus propias excepciones sólo con heredar de la clase Exception o de una de sus clases derivadas. Lo lógico es heredar de la clase de la jerarquía de Java que mejor se adapte al tipo de excepción. Las clases Exception suelen tener dos constructores: 1. Un constructor sin argumentos. 2. Un constructor que recibe un String como argumento. En este String se suele definir un mensaje que explica el tipo de excepción generada. Conviene que este constructor llame al constructor de la clase de la que deriva super(string). Al ser clases como cualquier otra se podrían incluir variables y métodos nuevos. Por ejemplo: class MiExcepcion extends Exception { public MiExcepcion() { // Constructor por defecto super(); public MiExcepción(String s) { // Constructor con mensaje super(s);
7 Las clases java.lang.throwable y sus Subclases Throwable Error LinkageError ClassCircularityError ClassFormatError ExceptionInInitializerError Por heredar de Throwable todos los tipos de excepciones pueden usar los métodos siguientes: String getmessage() Extrae el mensaje asociado con la IncompatibleClassChangeError excepción. AbstractMethodError IllegalAccessError InstantiationError String tostring() NoSuchFieldError NoSuchMethodError Devuelve un String que describe la NoClassDefFoundError excepción. UnsatisfiedLinkError VerifyError void printstacktrace() VirtualMachineError InternalError Indica la traza de los métodos OutOfMemoryError StackOverflowError donde se lanzó la excepción. UnknownError ThreadDeath Exception ClassNotFoundException CloneNotSupportedException IllegalAccessException InstantiationException InterruptedException RuntimeException ArithmeticException ArrayStoreException ClassCastException IllegalArgumentException IllegalThreadStateException NumberFormatException IllegalMonitorStateException IndexOutOfBoundsException NegativeArraySizeException NullPointerException SecurityException IOException EOFException FileNotFoundException InterruptedIOException UTFDataFormatException AWTException Referencias: http://java.sun.com/docs/books/tutorial/essential/exceptions/throwable.html http://java.sun.com/docs/books/jls/first_edition/html/javalang.doc20.html#46198