El modelo de un mecanismo de excepciones consta, fundamentalmente, de cinco nuevas palabras reservadas try, throw, throws, catch y finally.
- try, un bloque para detectar excepciones.
- catch, un manejador para capturar excepciones de los bloques try.
- throw, una expresión para levantar (raise) excepciones.
- throws, indica las excepciones que puede elevar un método.
- finally, bloque opcional, situado después de los catch de un try.
Los pasos del modelo son:
- Primero, el programador establece un conjunto de operaciones para anticipar errores. Esto se realiza en un bloque try.
- Cuando una rutina encuentra un error, se «lanza» (throw) una excepción. El lanzamiento (throwing) de una excepción es el acto de levantar una excepción.
- Por último, alguien interesado en una condición de error (para limpieza y/o recuperación) anticipará el error y «capturará» (catch) la excepción que se ha lanzado.
El mecanismo de excepciones se completa con:
- Un bloque finally que, si se especifica, siempre se ejecuta al final de un try.
- Especificaciones de excepciones que dictamina cuáles excepciones, si existen, puede lanzar un método.
El modelo de manejo de excepciones
La filosofía que subyace en el modelo de manejo de excepciones es simple. El código que trata con un problema no es el mismo código que lo detecta. Cuando una excepción se encuentra en un programa, la parte del programa que detecta la excepción puede comunicar que la expresión ha ocurrido levantando, o lanzando (throwing), una excepción.
De hecho, cuando el código de usuario llama a un método incorrectamente o utiliza un objeto de una clase de manera inadecuada, la biblioteca de la clase crea un objeto excepción que contiene información sobre lo que era incorrecto. La biblioteca levanta (raise) una excepción, una acción que hace el objeto excepción disponible al código de usuario a través de un manejador de excepciones. El código de usuario que maneja la excepción puede decidir qué hacer con el objeto excepción. El cortafuegos que actúa de puente entre una biblioteca de clases y una aplicación debe hacer varias cosas para gestionar debidamente el flujo de excepciones, reservando y liberando memoria de modo dinámico. (Ver Manejo de excepciones en Java)
Manejo de excepciones construye un «cortafuego».
Una de las razones más significativas para utilizar excepciones es que las aplicaciones no pueden ignorarlas. Cuando el mecanismo de excepciones levanta una excepción, alguien debe tratarla. En caso contrario, la excepción es «no capturada» (uncaught) y el programa termina por omisión. Este poderoso concepto es el corazón del manejo de excepciones y fuerza a las aplicaciones a manejar excepciones en lugar de ignorarlas.
El mecanismo de excepciones de Java sigue un modelo de terminación. Esto implica que nunca vuelve al punto en que se levanta una excepción. Las excepciones no son como manejadores de interrupciones que bifurcan a una rutina de servicio antes de volver al spot de interrupción. Esta técnica (llamada resumption) tiene un alto tiempo suplementario, es propensa a bucles infinitos y es más complicado de implementar que el modelo de terminación. Diseñado para manejar solo excepciones síncronas con un solo hilo de control, el mecanismo de excepciones implementa un camino alternativo de una sola vía en diferentes sitios de su programa.
Ejemplo
Se escribe un fragmento de código Java en el que en el método main() se define un bloque try, en el que es invocado el método f() que lanza una excepción.
void escucha() throws Exception
{
// código que produce una excepción que se lanza
// . . .
throw new FException();
// . . .
}
static public void main(String[] args){
try{
escucha(); // método que puede lanzar cualquier excepción
// código normal aquí
}
catch(FException t){
// captura una excepción de tipo FException
// hacer algo
}
catch(Exception e){
// captura cualquier excepción
// hacer algo
}
// resto de código
}
escucha() es un simple procedimiento en el que se ha declarado que puede lanzar cualquier excepción. Esto se hace en la cabecera del método, con:
throws Exception
Exception es clase base de las excepciones que son tratadas. Debido a la conversión automática entre clase derivada y clase base, se afirma que puede lanzar cualquier excepción. Cuando el método encuentra una condición de error lanza una excepción. Esto se hace con la sentencia:
throw new FException();
El operando de la expresión throw es un objeto. Normalmente los objetos almacenan información sobre el error ocurrido. Java proporciona una jerarquía de clases para el manejo de excepciones; el programador puede declarar clases para el tratamiento de errores en la aplicación. En el método main(), la llamada a escucha() se encierra en un bloque try. Este es un bloque de código encerrado dentro de una sentencia try:
try{
// . . .
}
Un bloque catch() captura una excepción del tipo indicado. En el ejemplo anterior se han especificado dos:
catch(FException t)
catch(Exception e)
Una expresión catch es comparable a un procedimiento con un único argumento.