Java Exceptions

Una excepción es una condición excepcional que cambia el flujo normal del programa. Cuando tal evento se produce en Java, una excepción es lanzada y la ejecución del programa se transfiere al código responsable de tratar a esta excepción. Este mecanismo para tratar excepciones ofrece varias ventajas. A través de él es posible aislar el código responsable del tratamiento de los errores en bloques separados, dejando el código principal más limpio. También puede tratar los errores similares con un solo bloque, eliminando el código duplicado.

Incluso existe la posibilidad de transferir el tratamiento de una excepción a otros métodos de la pila. Para indicar a la JVM que código debe ser ejecutado cuando ocurre una excepción, se utilizan los bloques try / catch.
Dentro de try se pone el código que puede generar una excepción y, a continuación, se colocan uno o más bloques catch, correspondientes a las excepciones que puedan ocurrir. Los bloques catch deben estar despúes del bloque try y reciben un objeto de la excepción como un argumento, que siempre será una subclase de Excepción. Ejemplo:
try {
// Código que puede generar una excepción
// Una línea mas para en el bloque try
}catch(PrimeraException e1) {
   // Código para tratar a excepción PrimeraException
   // Se pueden utilizar métodos para obtener mas información, tales como e1.printStackTrace();
}catch(SegundaException e2) {
   // Código para tratar a excepción SegundaException
}
// Código normal comienza aqui

Las líneas 2 y 3 son la región que intentará ser ejecutada por el bloque try. Las 6 y 7 tratan excepciones de tipo PrimeraException y la 10 de SegundaException. La aplicación comenzará en la línea 2, y si todo viene bien antes de la línea 3, el programa se reanudará en la línea 12. Pero si una excepción PrimeraException ocurre en las líneas 2 o 3, la ejecución irá de inmediato a la línea 6, pasará por todo el bloque catch hasta la línea 7 y luego irá a la línea 12, donde vuelve a la ejecución normal del código .
Tenga en cuenta que si ocurre una excepción en la línea 2, el resto del bloque try no será ejecutado. De este modo, el código que depende de cualquier operación de riesgo suele ser agrupado dentro del bloque try.
Por ejemplo, la primera línea intenta abrir un archivo, y dentro del mismo bloque try, intenta leer los datos en este fichero. Si Java no puede abrir el archivo, irá de manera directa el bloque catch, no tratando de leer los datos del archivo.
Un bloque catch puede tratar cualquier excepción que sea de la misma clase o una subclase que declaró. Las excepciones que no son tratadas en las correspondientes bloques catch donde fueron ocasionadas son pasadas al método anterior de la pila. La propagación se produce sucesivamente hasta que algún método haga el catch o hasta llegar al main, llegando a JVM, que detiene la aplicación y muestra el stack trace en la salida.
Es posible hacer un bloque catch para la captura de una excepción específica y una para todas las demás subclases de una excepción. Pero es necesario que el catch más específico (subclase) aparezca antes que el catch más general (superclase). De lo contrario, el programa no compila, dando un mensaje de error diciendo que la excepción es tratada ya anteriormente.
El bloque finally puede aparecer después del try / catch. Allí se pone el código que siempre debe ser ejecutado, ocurra una excepción o no. Un buen uso es para liberar recursos que se utilizan en el try (cerrar un archivo, la conexión a la base de datos, etc.) El finally se ejecuta siempre, incluso si hay un return en el método dentro del try. Él sólo no es ejecutado si la JVM está desligada, a través de unSystem.exit () o un error irreversible. Cuando ocurre una excepción, se ejecuta después del catch, de lo contrario, justo después deltry.
Tanto la cláusula finally como catch son opcionales, pero debe tener al menos uno por cada bloque try.
La clase Exception es una subclase de Throwable, que proporciona algunos métodos muy útiles para obtener información acerca de una excepción, como printStackTrace(). Otra subclase de Throwable es Error. Los errores y RuntimeExceptions se consideran uncheked, lo que lleva a que el compilador no requiere que exista tratamiento para ellos. Los errores suelen representar situaciones críticas, que no debería ocurrir, como que no haya mas memoria en la JVM. Las RuntimeExceptions (que son una subclase deException) indican errores de programación o condiciones especiales, difíciles de ser tratadas.
Las otras excepciones por lo general indican que una condición necesaria para la ejecución de un programa no está presente, como por ejemplo que un recurso no está disponible. Para todas las subclases de Throwable es posible utilizar el throw/throws y catch.
Las excepciones que lanza un método se debe declarar por medio de la palabra throws, en este caso serán del tipo checked. Eso no significa que necesariamente se lanzará la excepción, sólo que esto puede suceder. Si el método no trata una excepción que él recibe, también será necesario declararla para dárselo a la pila. Ejemplo:
void metodo() throws UnaException, DosException {
   // código del método
}
Cada método debe tratar todas las excepciones (checked) a través de métodos catch, o listar en su declaración cada excepción que no es tratada. Para pasar una excepción que se recibe en cláusula catch también es necesario que se declare en el método. Para crear su propia excepción simplemente extender la clase Exception, como sigue:
class MiException extends Exception { }
La nueva excepción deben seguir las normas establecidas para el manejo de excepciones, siendo tratada o lanzada a el próximo método.

No hay comentarios:

Publicar un comentario en la entrada