Jerarquía de de Errores y Excepciones De la ejecución de nuestros programas va a surgir una serie de errores que debemos manejar de alguna manera. Para esto debemos determinar qué los provoca y, una vez definido eso, analizar qué camino tomar, evitar el error, mostrar un mensaje comprensible para el usuario, abortar la ejecución del programa, etc. Java define una excepción como un objeto que es una instancia de la clase Throwable, o alguna de sus subclases. s decir que estamos ante una jerarqu!a de excepciones. Para comenzar, de "#ro$able #eredan las Error y Exception clases Error y . -lass+otoundxception /nterruptedxception
Exception
/&xception 0untimexception 1*xception
&bject
"#ro$able *in3agerror 45"rror
rror "#readDeat# 2irtual'ac#inerror
Por lo general, un error tiende a provocarse en condiciones anormales, eso significa que no tiene sentido o no es posible capturarlo. Por ejemplo, %&ut&f'emoryrror( indica que no #ay m)s memoria. Debido a la imposibilidad de capturar los errores, el programa termina. *as excepciones, en cambio, se producen dentro de condiciones normales, es decir que no sólo es posible capturarlas, sino que también el lenguaje nos obliga a capturarlas y manejarlas. +unca olvidemos olvi demos que qu e una excepción excepci ón no es un error , sino un evento que nuestro nue stro programa progra ma no sabe cómo manejar. iempre que se provoque una excepción, podemos capturarla y manejarla, o evitarla cambiando la lógica del programa.
Control de Excepciones (try… catch… finally) Para capturar y manejar las excepciones, Java proporciona las siguientes sentencias6 try, catch y finally ntre un try y un catc# vamos a escribir el código de programa que pueda provocar una excepción. *a estructura general es la siguiente6 try{ // Acá va el bloque que puede provocar una excepción } catch(NombreDeLaExcepcion intancia!{ // Acá va el bloque que mane"a la excepción en cao de producire }
n el catc# va el nombre de la excepción que deseamos capturar. i no sabemos qué excepción es, recordemos que #ay una jerarqu!a de excepciones, de tal forma que se puede poner la clase padre de todas las excepciones6 Exception 2eamos un ejemplo que produce una excepción, pero no vamos a capturarla, para analizar un poco la salida de error # public cla E"emploException { $ % private tatic int&' arrelo ) ne* int&+', + public tatic void main(.trin&' ar! {
0or(int x)1, x2+, x33!{ arrelo&x' ) x5$, } 8uetraArray(!,
4 6 7 #1 ## #$ #% #- #+ #
} public tatic void 8uetraArray(!{ 0or(int x)1, x2)+, x33!{ .ytem9out9println(arrelo&x'!, } }
#4 }
4l compilar y ejecutar el programa se obtiene lo siguiente6 0 2 4 6 8 Exception in thread "main" java.lang.ArrayIndexOutO!oundException# $ at ejemploexception.EjemploException.%uetraArray&EjemploException.java#'4( at ejemploexception.EjemploException.main&EjemploException.java#)( *ava +eult# '
l programa no causa ning7n error de compilación, pero s! un error de ejecución. sto es un RuntieException. 4nalizando el error vemos, primero, el nombre de la excepción provocada, en este caso !rray"ndex#ut#f$oundsException, y a continuación, el mensaje de error. *uego de informar la excepción, muestra la l!nea exacta en que fue provocada. s conveniente leer esto de abajo #acia arriba, de manera tal que podamos ver dónde empezó todo e ir siguiéndolo con nuestro código. 2emos que todo empezó en la l!nea 8, de paquete %ejemploexception(, en la clase %jemploxception(, en el método %main(. i vamos a esta l!nea vemos que es donde llamamos el método 'uestra4rray9:. eguimos #acia arriba, y a#ora vemos que el error est) en la l!nea ;< del paquete %ejemploexception(, en la salida por pantalla, en esta l!nea es donde sacamos un elemento del arreglo, es entonces cuando determinamos cu)l es la l!nea de código que provoca el error y por qué. 4#ora debemos elegir una solución. Podemos cambiar el l!mite del 0or de = a <, para asegurarnos de no querer sacar m)s elementos, o podemos capturar la excepción y manejarla. Para capturar la excepción debemos poner las l!neas que provocaron la excepción entre un try y un catch n el ejemplo anterior debemos encerrar al ciclo for del método 'uestra4rray9:6 # public cla E"emploException { $ % private tatic int&' arrelo ) ne* int&+', + public tatic void main(.trin&' ar! {
0or(int x)1, x2+, x33!{ arrelo&x' ) x5$, } 8uetraArray(!,
4 6 7 #1 ## #$ #% ##+ # #4 #6 #7 $1 $#
} public tatic void 8uetraArray(!{ try{ 0or(int x)1, x2)+, x33!{ .ytem9out9println(arrelo&x'!, } } catch(Array:ndex;ut;0!, } }
$$ }
4#ora la salida es la siguiente6 0 2 4 6 8 ,e intent- acar m elemento
-omo vemos, lo 7nico que logramos es mostrar el mismo error, sólo que de manera mas comprensible. n ciertos casos, vamos a usar el bloque catch para evitar el error, no sólo
para mostrarlo. l lenguaje no nos obliga a capturar las excepciones que se provocan en tiempo de ejecución, sin embargo, éstas se producen, y muy a menudo. ntonces, empezar) ejecutando el try, si se produce alguna excepción, corta el try y ejecuta el catch. inalmente, lo que va en el bloque finally, se ejecutar) siempre, #aya #abido excepciones o no. 4lgo muy com7n es usar dic#o bloque para limpiar variables, cerrar arc#ivos, restablecer conexiones, es decir, tareas que #ayan podido quedar truncadas seg7n se #aya ejecutado el try completo o no. *a estructura de un bloque con try, catc# y finally es la siguiente6 try{ // Acá va el bloque que puede provocar una excepción } catch(NombreDeLaExcepcion intancia!{ // Acá va el bloque que mane"a la excepción en cao de producire } 0inally{ // Ete bloque e e"ecuta iempre in importar i e e"ecuto el // bloque del try o del catch }
Excepciones %en&ricas' Podemos tener cuantos catch creamos necesarios, cada uno para capturar una excepción especifica, con la ventaja que podremos manejar cada una de ellas de manera distinta, pero puede suceder que como resultado de la ejecución del programa se provoque una excepción que el programa no estaba preparado para manejar. 4provec#ando la jerarqu!a de excepciones, podemos reemplazar todos los catch de excepciones particulares por la superclase Exception, #aciendo una captura genérica. Para tener una idea del problema ocurrido se pueden utilizar los objetos etessa*e() o print+tacTrace(). ## #$ #% ##+ # #4 #6 #7 $1 $# $$ }
public tatic void 8uetraArray(!{ try{ 0or(int x)1, x2)+, x33!{ .ytem9out9println(arrelo&x'!, } } catch(Exception ex!{ ex9print.tac?@race(!, } }
!se-eraciones (assert) *as aseveraciones permiten comprobar las presunciones que #aces sobre el código mientras se esta desarrollando, sin tener que manejar excepciones que se cree que nunca, ocurrir)n. intaxis6 aert (condición!, ó aert (condición! C =8ena"e>
upongamos que se escribe un código seg7n el cual si x>?, sucede una cosa, y si x@@?, sucede otra. e puede expresar de la siguiente manera6 i0 (x 1!{ // Bódio en cao que e cumpla la condición } ele{ // Bódio en cao que N; e cumpla la condición }
e supone que nunca suceder) que x./A pero, By si algo va mal y resulta que x tiene un valor negativoC n este caso, se ejecutar!a la parte de código correspondiente a else, como si x00/, con resultados impredecibles. Para evitarlo, se puede usar una aseveración6 i0 (x 1!{ // Bódio en cao que e cumpla la condición } ele{ aert (x )) 1!, // Bódio en cao que N; e cumpla la condición }
!cti-aci1n de las !se-eraciones en 2et$eans 34/' ile Project Properties 9nombre del proyecto: legir la opción %0un(, y en %2' &ptions( agregar el siguiente par)metro %Eenableassertions( 9sin comillas:
