Está en la página 1de 9

Resumen del Capítulo 10 del Libro The Java Reference

La gestión de excepciones de Java evita estos problemas e incorpora el manejo de errores en


tiempo de ejecución.

Fundamentos de la gestión de excepciones


Cuando surge una condición excepcional, se crea un objeto que representa esa excepción y se
envía el método que ha originado el error. La excepción es capturada y procesada.
Las excepciones generadas por el código se usan normalmente para informar de alguna
condición de error a un método que llamó a otro.
La gestión de excepciones en Java se lleva a cabo mediante 5 palabras try, catch, throw
,thorws y finally.
La sentencias del programa que se quieran monitorear, se incluye en un bloque try, está es
lanzada. El código puede capturar esta excepción, utilizando el catch, y gestionarla de forma
racional. Estas se envían de manera automática.
Si se decide enviar de manera manual se utiliza throw. Y se especifica con la cláusula throws
cualquier excepción que se envie desde un método al método exterior que lo llamó. Se debe
poner cualquier código que el programador desee que se ejecute siempre, después de que un
bloque try se complete, en el bloque de la sentencia finally.
La forma general de un bloque de gestión de excepciones es la siguiente.
try{
//bloque de código a monitorear por errores
}
catch(TipoExcepción1 ex Ob){
//gestor de excepciones para ExcepciónTipo1
}
catch(TipoExpecion2 exOb){
//gestor de excepciones para ExcepciónTipo2
}
//…
finally{
//bloque de código que se debe ejecutar después de que el bloque try termine
}
Donde TipoExcepcion es el tipo de la excepción que se ha producido. El resto de este capítulo
describe como se aplica la gestión de excepciones.

Tipos de excepciones
Según la jerarquía Throwable se encuentra en la parte superior después la siguen 2 grupos
Exception que dentro de esta se divide en subclases y Error que define excepciones no
esperadas por el programa en condiciones normales. El intérprete Java utiliza las excepciones
del tipo Error para indicar errores relacionados con el propio ambiente de ejecución.
Excepciones no capturadas
En el caso de una división por cero, genera un nuevo objeto de clase Exception, y lanza dicha
excepción. Esto da lugar a que se detenga la ejecución de Exc0, ya que excepción debe ser
capturada y tratada. Pero en el caso no se proporcionó gestores de excepciones propios, de
forma que la excepción es capturada por un gestor por defecto.
En la cual se mostrara el tipo de error y en cual línea de la pila se produjo ese error, además
que se presentara una subclase de la excepción de manera más específica en este caso será
ArithmeticExcepción.

Utilización try & catch


A pesar del sistema gestión de excepción que proporciona Java(por defecto),es preferible usar
las excepciones propias. Esto evita que el programa termine de manera automática y evita que
el programa suspendiera la ejecución e imprimiese un trazado de la línea en la cual se produce
el error. Para evitar esto y para proteger de esta situación y gestionar un erro en tiempo de
ejecución.
Lo que se hace es encerrar el bloque del código con un try, inmediatamente después se incluye
la sentencia catch, que especifica el tipo de excepción que se desea capturar.
Una vez que se lanza una excepción, el control del programa se transfiere directamente al
catch. Esto da de entender que try/catch trabaja de manera conjunta.
La función del catch bien debe ser resolver una condición excepcional y continuar como si el
error nunca hubiera existido.

Descripción de una excepción


La clase Throwable sobrescribe el método toString() definido por la clase Object para que
devuelva una cadena que contiene la descripción de la excepción. De esta forma se puede
presentar esta descripción mediante la sentencia println(), simplemente pasándole la
excepción como argumento.
Cláusulas catch múltiples
En algunos casos, en una misma secuencia de código puede activar más de un tipo de
excepción. Para estos casos se utilizan dos o más sentencias catch, capturando a cada una de
ellas un tipo diferente de excepción.
Cuando se utiliza varias sentencias catch, es importante recordar que las subclases de la clase
Excepción debe estar delante de cualquiera de sus superclases. Esto se debe a una sentencia
catch que utiliza una superclase captura las excepciones de sus clases y, por lo tanto, éstas no
sé ejecutarán si están después de una superclase.

Sentencias try anidadas


La sentencia try puede ser aninada. Esto es, una sentencia try puede estar dentro del bloque
de otro try. Cada vez que una sentencia try es ingresada, el contexto de esa excepción se
vuelve a colocar en la pila. Si una sentencia try colocada en el cuerpo de otra sentencia try no
realiza la gestión de una excepción particular, la pila es liberada y la siguiente sentencia try
inspeccionada en busca de una coincidencia. Esto continua hasta que una de las sentencias
catch tiene éxito o hasta que todas las sentencias try aninadas han sido pasadas. Si ninguna
sentencia catch coincide, la máquina virtual de Java atrapará la excepción. Veamos un ejemplo
de sentencia try aninadas.
El anidamiento de sentencias, try puede ocurrir de manera menos evidente cuando están de
por medio invocaciones a métodos. Por ejemplo, podemos encerrar una llamada a un método
en un bloque try y dentro de este método colocar otra sentencia try. En este caso, la sentencia
try en el método se considera aninada dentro del bloque try externo que mandó llamar al
método.

Throw
También el propio programa puede lanzar explícitamente una excepción mediante la sentencia
thorw. La forma general de esta sentencia es la siguiente.
throw objeto Throwable;
Donde objetoThrowable debe ser un objeto del tipo Throwable o una subclase de Thorwable.
Se puede obtener un objeto de la clase Throwable de dos formas: utilizando un parámetro en
la cláusula catch, o creando un nuevo objeto con el operador new.
La ejecución del programa se para inmediatamente después de una sentencia throw; y
cualquiera de las sentencias que siguen no se ejecutarán. A continuación se inspecciona el
bloque try más próximo que la encierra, para ver si contiene una sentencia catch que coincida
con el tipo de excepción. Si es así, el control se transfiere a esa sentencia. Si es así, el control se
transfiere a esa sentencia. Si no, se inspecciona el siguiente bloque try que la engloba, y así
sucesivamente. Si no se encuentra una sentencia catch cuyo tipo coincida con el de la
excepción, entonces el gestor de excepciones por omisión interrumpe el programa e imprime
el trazado de la pila.

Throws
Si un método puede dar lugar a una excepción que no es capaz de gestionar él mismo, se debe
especificar este comportamiento de forma que los métodos que llamen al principio puedan
protegerse contra esta excepción. Para ello se incluye una cláusula throws en la declaración del
método. Una cláusula throws da un listado de los tipos de excepciones que le método podría
lanzar.Esto es necesario para toda las excepciones, excepto las del tipo Error o
RuntimeException, o cualquiera de sus subclases.
Todas las demás excepciones que un método puede lanzar se deben declarar en la cláusula
throws.Si esto no se hace así, el resultado es un error de compilación.
La forma general de la declaración de un método que incluye una sentencia throws es la
siguiente:-
tipo nombre_método(lista_de_parametros) throws lista_de_excepciones
{
// cuerpo del método
}
Donde, lista_de_excepciones es una lista de las excepciones que el método puede lanzar,
separadas por comas.
A continuación se muestra un programa incorrecto que trata de lanzar una excepción que no
captura. Como el programa no específica una sentencia throws que declare este hecho, no se
compilará.
finally
Cuando se lanzan excepciones, la ejecución dentro de un método sigue un camino no lineal y
bastante brusco que altera el flujo normal. Dependiendo de cómo se haya codificado el
método, puede incluso suceder que una excepción provoque que el método finalice de forma
prematura. Esto puede ser un problema en algunos casos.
finally crea un bloque de código que se ejecutará después de que se haya completado un
bloque try/catch y antes de que se ejecute el código que sigue al bloque try/catch. El bloque
finally se ejecuta independientemente de que se haya lanzado o no alguna excepción. Si se ha
coincida con la excepción. Cuando un método está a punto de devolver el control al método
llamante desde dentro de un bloque try/catch por medio de una excepción no capturada o de
una sentencia return explícita, se ejecuta también la cláusula finally justo antes de que el
método devuelva el control. Esta acción tiene utilidad para cerrar descriptores de archivos o
liberar cualquier otro recurso que se hubiera asignado al comienzo de un método con la
intención de liberarlo antes de devolver el control. La cláusula finally es opcional. Sin embargo,
cada sentencia try requiere, al menos, una sentencia catch o finally.

Excepciones integradas en Java


Dentro del paquete estándar java.lang Java define varias clases de excepciones. Algunas ya se
han usado en los ejemplos anteriores. Las excepciones más comunes son subclases del tipo
estándar RuntimeException.
Dentro del lenguaje Java, se denomina excepciones no comprobadas a estas excepciones, ya
que el compilador no controla si el método gestiona o lanza estas excepciones.

Creando excepciones propias


Aunque las excepciones del núcleo de Java gestionan la mayor parte de los errores habituales,
nosotros podríamos desear crear nuestros propios tipos de excepciones para tratar situaciones
específicas que se presenten aplicaciones. Esto se puede hacer de forma bastante sencilla,
definiendo una subclase de la clase Exception, que es por supuesto, una subclase de
Throwable. No es necesario que estas subclases creadas por el usuario implemente nada;
simplemente, su existencia en el sistema nos permitirá usarlas como excepciones.
La clase Exception no define por sí misma método alguno, pero hereda, evidentemente, los
métodos que proporciona la clase Throwable. Además, todas las excepciones, incluyendo las
creadas por nostros, pueden disponer de los métodos definidos por la clase Throwable.
Además, estos métodos se pueden sobrescribir en las clases de excepción propias.
La clase Excepction define cuatro constructores. Dos de ellos para soportar excepciones
encadenadas, se describen en la siguiente sección. Los otros dos se describen así
Exception()
Exception(String msg)
La primera forma crea una excepción sin descripción. La segunda forma nos permite especificar
una descripción para la excepción.
Aunque especificar una descripción cuando se crea una excepción es útil, algunas veces es
mejor sobrescribir al método toString(), esto debido a que la versión de toString() definida por
la clase Throwable y heredada por la clase Exception primero despliega el nombre de la
excepción y los dos puntos, con ellos podemos generar una salida más limpia, deseable en
algunos casos.
Excepciones encadenadas
La característica de excepción encadenada nos permite asociar una excepción con otra. Esta
segunda excepción describe la causa de la primera excepción.
Las excepciones encadenadas nos permiten gestionar ésta y otras situaciones en las cuales
existen capas o niveles de excepciones.
Para crear excepciones encadenadas se añadieron dos métodos y dos constructores a la clase
Throwable. Los constructores son:
Throwable(Throwable exc)
Throwable(String msg, Throwable exc)
En la primera forma, exc es la excepción que causa a la excepción actual. Esto es, exc es la razón
subyacente a la ocurrencia de la nueva excepción. La segunda forma nos permite especificar
una descripción al mismo tiempo que se especifica la excepción causante de la actual. Estos
dos constructores también han sido añadidos a las clases Erroe, Excepcion y RuntimeException
Los métodos de encadenado de excepciones añadidos a la clase Throwable son getCause() e
initCuase(). Estos métodos se muestran
Throwable getCause()
Throwable initCause(Throwable exc)
El método getCause() regresa la excepción subyacente a la excepción actual. Si no existe una
excepción subyacente regresa null. El método initCause() asocia exc con la excepción que
realiza la invocación y regresa una referencia a la excepción. Así podemos asociar una causa
con una excepción después de que la excepción ha sido creada. Sin embargo, la excepción
causante puede ser asociada solo una vez. Por ello, es posible llamar a initCause( ) solo una vez
para cada objeto de excepción. Si la excepción causante fue establecida por una constructor, no
es posible establecerla de nuevo utilizando initCause(). En general, initCause( ) es utilizada
para asignar una causa a excepciones cuyas clases tipo no cuentan con los dos constructores
adicionales descritos antes.
Utilizando excepciones
La gestión de excepciones proporciona un mecanismo muy potente para controlar progmras
complejos, con características dinámicas, durante la ejecución. Es importante considerar a try,,
throw y catch como formas limpias de gestionar errores y problemas inespedarados en la
lógica.