5.1 Definición de excepciones

 

Una excepción es un evento que ocurre durante la ejecución de un programa y detiene el flujo normal de la secuencia de instrucciones de ese programa; en otras palabras, una excepción es una condición anormal que surge en una secuencia de código durante su ejecución.

Las excepciones en Java están destinadas, al igual que en el resto de los lenguajes que las soportan, para la detección y corrección de errores. Si hay un error, la aplicación no debería morirse y generar un core (o un crash en caso del DOS). Se debería lanzar (throw) una excepción que a su vez debería capturar (catch) y resolver la situación de error, o poder ser tratada finalmente (finally) por un gestor por defecto u omisión. Java sigue el mismo modelo de excepciones que se utiliza en C++. Utilizadas en forma adecuada, las excepciones aumentan en gran medida la robustez de las aplicaciones.

La gestión de excepciones en Java proporciona un mecanismo excepcionalmente poderoso para controlar programas que tengan muchas características dinámicas durante su ejecución. Las excepciones son formas muy limpias de manejar errores y problemas inesperados en la lógica del programa, y no deberían considerarse como un mecanismo general de ramificaciones o un tipo de sentencias de salto. Los lugares más indicados para utilizar excepciones son aquellos en los que se usan valores como 0 o 1, en C/C++, para indicar algún fallo funcional. Por ejemplo:

#include <sys/errno.h>

int fd;

fd = open( "leeme.txt" );

if( fd == -1 && errno == EEXIT )

fd = open( "defecto.txt" );

}

Proporciona una oportunidad para capturar una excepción más genérica y tratar la situación con elegancia o, en el peor de los casos, imprimiría el estado de la pila de memoria.

Por ello, que la utilización adecuada de las excepciones proporcionará un refinamiento profesional al código que cualquier usuario futuro de las aplicaciones que salgan de la mano del programador que las utilice agradecerá con toda seguridad.

 

 

 

 

 

 

5.2 Tipos de exepciones

Tipos de excepciones

Existen varios tipos fundamentales de excepciones:

• Error: Excepciones que indican problemas muy graves, que suelen ser no recuperables y no deben casi nunca ser capturadas.
• Exception: Excepciones no definitivas, pero que se detectan fuera del tiempo de ejecución.
• RuntimeException: Excepciones que se dan durante la ejecución del programa.

 

 

 

Todas las excepciones tienen como clase base la clase Throwable, que está incluida en el paquete java.lang, y sus métodos son:

• Trowable( String mensaje ); Constructor. La cadena es opcional
• Throwable fillInStackTrace(); Llena la pila de traza de ejecución.
• String getLocalizedMessage(); Crea una descripción local de este objeto.
• String getMessage(); Devuelve la cadena de error del objeto.
• void printStackTrace( PrintStream_o_PrintWriter s ); Imprime este objeto y su traza en el flujo del parámetro s, o en la salida estándar (por defecto).
• String toString; Devuelve una breve descripción del objeto.

 

 

 

 

 

 

5.3 Propagación de excepciones

 

Las instrucciones que tenemos dentro de un bloque try a menudo contienen llamadas a métodos que a su vez pueden realizar llamadas a otros métodos y así sucesivamente. Cualquiera de los métodos llamados puede provocar una excepción y cualquiera de los métodos puede, o no, tratarla (con bloques catch). Ó

Una excepción no tratada en un bloque se propaga hacia el bloque llamante. Este mecanismo de propagación continúa mientras no se trate la excepción o se llegue al método de nivel superior. Si la excepción no se trata en el método de nivel superior, se imprime un mensaje de error por consola.

En muchas ocasiones, después de tratar la excepción a un nivel, resulta conveniente que también sea tratada a niveles superiores; por ejemplo, si estando leyendo de un fichero origen y escribiendo su contenido en un fichero destino nos encontramos con un error de lectura, además de tratar la excepción a ese nivel (cerrar los ficheros, etc.) sería deseable propagar la excepción al programa llamante para que informe al usuario y le permita hacer un nuevo intento si lo desea.

Para propagar de forma explícita una excepción se emplea la palabra reservada throw seguida del objeto excepción. Ejemplo:

try {

// codigo

Origen.CopiaFichero(Destino);

// codigo

}

catch (IOException e) {

System.out.println (“Error de lectura ¿Desea intentarlo de Nuevo?”);

..........

}

 

public void CopiaFichero (TipoFichero Destino) {

try {

// codigo

}

catch (IOException e) {

// cerrar ficheros, etc.

throw e;

}

 

En el ejemplo anterior, el método CopiaFichero, después de tratar la excepción, la propaga (throw) al método llamante, que a su vez hace otro tratamiento de la excepción.

 

 

 

5.4 Gestión de excepciones

 

Lanzamiento de excepciones: throw - throws

Muchas veces el programador dentro de un determinado método deberá comprobar si alguna condición de excepción se cumple, y si es así lanzarla. Para ello se utilizan las palabras reservadas throw y throws.

 

Por una parte la excepción se lanza mediante la sentencia throw:

if ( condicion_de_excepcion == true )

throw new miExcepcion();

 

Se puede observar que hemos creado un objeto de la clase miExcepcion, puesto que las excepciones son objetos y por tanto deberán ser instanciadas antes de ser lanzadas.

Aquellos métodos que pueden lanzar excepciones, deben cuáles son esas excepciones en su declaración. Para ello se utiliza la sentencia throws:

 

tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 {

// Codigo capaz de lanzar excepciones miExcep1 y miExcep2

}

 

Se puede observar que cuando se pueden lanzar en el método más de una excepción se deben indicar en sus declaraciones separadas por comas.

 

Ejemplo de gestión de excepciones.

Ahora que ya sabemos cómo funciona este sistema, conviene ver al menos un pequeño ejemplo, que ilustre al lector en el uso de las excepciones:

 

// Creo una excepción personalizada

class MiExcepcion extends Exception {

MiExcepcion(){

super(); // constructor por defecto de Exception

}

 

MiExcepcion( String cadena ){

super( cadena ); // constructor param. de Exception

}

}

 

// Esta clase lanzará la excepción

class Lanzadora {

void lanzaSiNegativo( int param ) throws MiExcepcion {

if ( param < 0 )

throw new MiExcepcion( "Numero negativo" );

}

}

 

class Excepciones {

public static void main( String[] args ) {

// Para leer un fichero

Lanzadora lanza = new Lanzadora();

 

FileInputStream entrada = null;

int leo;

 

try {

entrada = new FileInputStream( "fich.txt" );

while ( ( leo = entrada.read() ) != -1 )

lanza.lanzaSiNegativo( leo );

entrada.close();

System.out.println( "Todo fue bien" );

} catch ( MiExcepcion e ){ // Personalizada

 

System.out.println( "Excepcion: " + e.getMessage() );

}

 

catch ( IOException e ){ // Estándar

System.out.println( "Excepcion: " + e.getMessage() );

}

 

finally {

if ( entrada != null )

try {

 

entrada.close(); // Siempre queda cerrado

} catch ( Exception e ) {

 

System.out.println( "Excepcion: " + e.getMessage() );

}

 

System.out.println( "Fichero cerrado." );

}

}

}

 

 

 

 

 

5.5. Creación y manejo de excepciones creadas por el usuario

 

Las excepciones predefinidas cubren las situaciones de error más habituales con las que nos podemos encontrar, relacionadas con el propio lenguaje y el hardware. Cuando se desarrollan aplicaciones existen otras situaciones de error de más ‘alto nivel’ relacionadas con la funcionalidad de nuestros programas.

 

Imaginemos una aplicación informática que controla la utilización de los remontes de una estación de esquí: los pases de acceso a los remontes son personales e intransferibles y dispondrán de un código de barras que los identifica. Cada vez que un usuario va a hacer uso de un remonte debe introducir su pase de acceso en una máquina de validación, que acciona un torno y devuelve el pase.

 

El sistema puede constar de un ordenador central al que le llegan telemáticamente los datos correspondientes a los códigos de barras de los pases que en cada momento se están introduciendo en cada máquina de validación de cada remonte; si un código de barras está en regla, el ordenador envía una orden de liberar el torno para permitir al usuario acceder al remonte. El ordenador central habitualmente recibirá códigos correctos utilizados en momentos adecuados, sin embargo, en ciertas ocasiones nos encontraremos con situaciones anómalas:

1 Código de barras ilegible

2 Código de barras no válido (por ejemplo correspondiente a un pase caducado)

3 Código de barras utilizado en otro remonte en un periodo de tiempo demasiado breve

4 etc.

 

Ninguna de las situaciones anteriores se puede detectar utilizando excepciones predefinidas, puesto que su naturaleza está estrechamente relacionada con los detalles de la aplicación (no del lenguaje o el sistema informático), por lo que tendremos que recurrir al método tradicional de incluir condiciones (if, case, ...) de comprobación o bien hacer uso de excepciones definidas por nosotros mismos (excepciones no predefinidas).

 

Antes de nada tenemos que tener en cuenta que el mecanismo de excepciones es muy lento en ejecución comparado con la utilización de instrucciones condicionales. Aunque el mecanismo de excepciones es elegante, debemos utilizarlo con prudencia: únicamente en situaciones que realmente son excepcionales.

 

La primera situación anómala de nuestro ejemplo (código de barras ilegible) podría ser tratada como excepción o bien a través de alguna instrucción condicional, depende de la frecuencia con la que se nos presente esta situación. Si ocurre, por ejemplo, en aproximadamente un 0.5% de los casos, tendremos un claro candidato a ser tratado como excepción. Si ocurre, digamos en un 14% de los casos, deberíamos pensar en tratarlo con rapidez por medio de instrucciones condicionales. Para tratar la segunda situación anómala del ejemplo (código de barras no valido) deberíamos aplicar un razonamiento equivalente al que acabamos de realizar.

 

Nuestro tercer caso nos presenta la situación de que un mismo pase de pistas ha podido ser duplicado (intencionadamente o por error), puesto que resulta físicamente imposible hacer uso de un remonte en un instante y volver a utilizarlo en otro remonte lejano medio minuto después. Probablemente esta situación se presenta muy rara vez y resultaría muy adecuado tratarla como excepción propia.

 

Una vez razonada la utilidad de este tipo de excepciones, veremos la manera de definirlas en Java

 

Defiicion de una execcion definida

En programación orientada a objetos lo más adecuado es que las excepciones sean objetos, por lo que en Java definiremos las excepciones como clases. Nuestras clases de excepción, en general, heredarán de la clase Exception.

 

En las clases que nos creemos a partir de Exception, incluiremos al menos el constructor vacío y otro que contenga un String como argumento. Este String se inicializa automáticamente con el nombre de la clase; la inicialización se realiza en la superclase Throwable. El texto que pongamos al hacer uso del segundo constructor se añadirá al nombre de la clase insertado por la superclase.

 

A continuación se presenta una clase (ExPropia) muy simple que define una excepción propia:

 

1 public class ExPropia extends Exception {

2

3 ExPropia () {

4 super("Esta es mi propia excepcion");

5 }

6

7 ExPropia (String s) {

8 super(s);

9 }

10

11 }