Excepción Una excepción es una condición anormal que se produce en una sentencia de código a tiempo de ejecución. En otras palabras, una excepción es un error en tiempo de ejecución. Una excepción Java es un objeto que describe una condición excepcional (esto es, error) que ha ocurrido a un segmento de código. Cuando surge una condición excepcional, se crea un objeto que representa una excepción y se lanza (throw) en el método que produce el error. El manejo de excepciones se gestiona mediante cinco palabras reservadas: try, catch, throw, throws y finally. Si al momento de ejecutar un programa ocurre un error, Java lanza una excepción, es un soporte que proporciona para el manejo de errores. Las excepciones en Java son objetos de subclases de Throwable que está definida en el paquete java.lang. Las excepciones se tienen que capturar y manejar para que se pueda reanudar la ejecución del programa. Manejo de excepciones Para capturar una excepción se tiene que escribir el bloque que puede generar un error dentro de try y para manejar esa excepción se utiliza catch como se muestra a continuación: try { // Código de la aplicación } catch(clase_de_excepción e) { //Código de tratamiento de esta excepción } catch (otra_clase_de_excepción e) { //Código de tratamiento para otra clase de excepción } finally{ //Código } Un bloque try puede estar seguido de uno o más bloques de catch. Cada catch debe tener un parámetro de la clase Throwable o de alguna subclase de ésta. Cuando se lance una excepción, el bloque catch que lo atrape será aquel cuyo parámetro sea de la clase o de una superclase de la excepción. Clase de excepción Bloque de finalización Si se desea realizar alguna acción por obligación como cerrar un archivo, liberar algún recurso externo que se haya adquirido, etc., se debe poner el código adecuado dentro de un bloque finally después del bloque try o de un bloque catch. El bloque finally debe ser siempre el último. La ejecución del bloque finally queda garantizada independientemente de que finalice o no la ejecución del bloque try. Los bloques try y finally se pueden utilizar conjuntamente sin que sea necesario incluir un bloque catch. Declarar excepciones La palabra reservada throws permite a un método declarar las listas de excepciones ( nombres de las clases de excepción separados por comas) que pueden lanzar. Esto tiene dos lecturas: 1.- Dar información a los usuarios de la clase que proporciona este método sobre las cosas anormales que puede hacer el método. 2.-Escribir un método que lance una o más excepciones que no sean atrapadas por el propio método, sino por los métodos que lo llamen. Crear y lanzar excepciones En Java podemos crear nuestras propias excepciones. Todos los tipos de excepción se corresponden con una clase derivada de Throwable, clase raíz de la jerarquía de clases de excepciones de Java. El paquete java.lang proporciona dos subclases de Throwable que agrupan las excepciones que se pueden lanzar, como consecuencia de los errores que pueden ocurrir en un programa, en dos clases: Error y Exception. Los errores que ocurren en la mayoría de los programas se corresponden con excepciones de alguna de las subclases de ExceptionError reservada para el tratamiento de los errores que se puedan producir en la máquina virtual de Java. Ejemplo: public class EValorNoValido extends Exception { public EValorNoValido() {} public EValorNoValido(String mensaje) { super(mensaje); } } Estamos utilizando la clase anterior para crear una excepción para un error no valido, la superclase es Exception e implementa dos constructores, uno sin parámetros y otro con un parámetro de tipo String. El parámetro de tipo String es el mensaje que devolverá el método getMessage heredado de la clase Throwable a través de Exception. Para ello el constructor EValorNoValido debe invocar al constructor de la superclase y pasar como argumento dicha cadena, la cual será almacenada como un miembro de datos de la clase Throwable. Ejemplo de aplicación public class MiClase { public void n(int x) { if(x==0) throw new EValorNoValido("Error: valor cero"); } } Lanzar una excepción equivale a crear un objeto de ese tipo de excepción. En este ejemplo lo que provoca el error es que el parámetro x del método n de MiClase es 0, en este caso el método n lanza una excepción de la clase EValorNoValido creando un objeto de esta clase. Para crear (new) ese objeto se invoca al constructor EValorNoValido pasando como argumento, en este caso, la cadena "Error:valor cero"; Si un método n lanza una excepción debe declararlo, para que los usuarios de MiClase, que es quien proporciona el método n, estén informados sobre las cosas anormales que puede hacer dicho método. public class MiClase { public void n (int x) throws EValorNoValido { if (x==0) throw new EValorNoValido("Error: valor cero"); } } Otra alternativa es que el propio método que lanza la excepción la atrape como se muestra en el siguiente ejemplo: public class CMiClase { public void n(int x) { try { if(a==0) throw new EValorNoValido("Error: valor cero"); } catch(EValorNoValido e ) { System.out.println(e.getMessage()); } } } Escribir un método que lance una o más excepciones y él mismo las atrape es anticiparse a las necesidades que pueda tener el usuario de la clase que proporciona ese método, en cuanto al tratamiento de la excepción se refiere. Ejemplo public class PruebaExcepcion{ public static void main(String [] args){ int [] a ={0,1,2,3,4,5}; try{ for (int i=0;i<6;i++){ System.out.println(“a[“+i+”]es “+a[i]); } } catch(excepcion e) { System.out.println(“Excepcion: “ +e); } System.out.println(“Código que se puede ejecutar”); } }