domingo, 26 de febrero de 2012

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

Para descargar el documento de este tema, haz clic aquí

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

Definición de una excepción definida por el programador
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  }


En la línea 1 se define nuestra clase Expropia que hereda de  Exception. La línea 3 define el constructor vacío, que en este caso añade el texto “Esta es mi propia excepcion” al nombre de la clase, quedando “ExPropia: Esta es mi propia excepcion”. La línea 7 define el constructor con un String como argumento; nos servirá para añadir el texto que deseemos al instanciar la clase.

Utilización de una excepción definida por el programador
Una vez que disponemos de una excepción propia, podremos programar la funcionalidad de nuestras aplicaciones provocando (lanzando) la excepción cuando detectemos alguna de las situaciones anómalas asociadas.

En el siguiente ejemplo (ExPropiaClase) se presenta un método (línea 2) que levanta ( throw) la excepción  ExPropia cuando se lee un cero (línea 4). La excepción ExPropia podría levantarse en diferentes secciones de código de esta u otras clases. No debemos olvidar indicar que nuestro método es susceptible de lanzar la excepción (línea 2).

1  public class ExPropiaClase {
2     public void Metodo() throws ExPropia {
3       if (Teclado.Lee_int() == 0)
4         throw new ExPropia();
5     }
6     // otros metodos
7  }

Finalmente, en clases de más alto nivel podemos programar secciones de código que recojan la excepción que hemos creado: 

1  public class ExPropiaPrueba {
2     public static void main (String[] args) {
3        System.out.println("Hola");
4       do 
5        try {
6          ExPropiaClase Instancia = new ExPropiaClase(); 
7          Instancia.Metodo();
8        }
9        catch(ExPropia e) {
10          System.out.println(e);
11        }
12       while(true);
13     }
14  }

Como se puede observar en la clase  ExPropiaPrueba, podemos insertar código en un bloque  try asociándole un bloque  catch que recoge la excepción que hemos definido (ExPropia). A continuación se muestra un posible resultado de la ejecución de ExPropiaPrueba.
Ejemplo
En los apartados anteriores hemos definido y utilizado una excepción con sus constructores básicos, pero sin propiedades ni métodos adicionales. En ocasiones con el esquema seguido es suficiente, sin embargo, a menudo es adecuado dotar de un estado (propiedades) a la clase que define la excepción. Veamos este concepto con un ejemplo sencillo: deseamos programar la introducción por teclado de matrículas de vehículos en un país donde las matrículas se componen de 8 caracteres,  siendo obligatoriamente el primero de ellos una letra. Si alguna matrícula introducida por el usuario no sigue el formato esperado se recogerá la interrupción oportuna y se escribirá un aviso en la consola.

En el código siguiente se presenta la clase  ExMatricula que hereda la funcionalidad de Exception (línea 1). Los constructores situados en las líneas 6 y 9 permiten iniciar el estado de la clase a través de los constructores de su superclase.
En la línea 2 se define la propiedad MalFormada, que contiene información sobre la razón por la que el formato de la matrícula es incorrecto: tamaño inadecuado (línea 3) o inexistencia de la letra inicial (línea 5). 
El constructor de la línea 13 permite crear una excepción  ExMatricula indicando la naturaleza del pro blema que obligará a levantar (trhow) esta excepción (ExMatricula.MAL_TAMANIO o ExMatricula.MAL_LETRA).
En la línea 17 se suministra un método que permitirá, a los programas que reciben la excepción, saber la razón que ha provocado la misma.

public class ExMatricula extends Exception {
private int MalFormada = 0;
static final int MAL_TAMANIO = -1;
static final int MAL_LETRA = -2;
ExMatricula() 
{}
ExMatricula(String s) {
super(s);
}
ExMatricula(int MalFormada) {
this.MalFormada = MalFormada;
}
public int DimeProblema() {
return MalFormada;
}
}

Una vez creada la excepción  ExMatricula podemos escribir el código que valida las matrículas. La siguiente clase (ExMatriculaValidar) realiza este cometido: el método  Validar situado en la línea 6 comprueba el formato del parámetro suministrado y si es necesario tendrá capacidad de levantar (throws) la excepción ExMatricula.
Si la longitud de la matrícula es distinta de 8 caracteres (línea 8) se crea y levanta la excepción  ExMatricula con estado inicial  ExMatricula.MAL_TAMANIO (línea 9). Si el carácter inicial no es una letra (línea 11) se crea y levanta la excepción ExMatricula con estado inicial ExMatricula.MAL_LETRA (línea 12).
El método privado (sólo es visible en esta clase) Una letra aísla el primer carácter y comprueba que es una letra empleando el método matches y la expresión regular “[A-Za-z]”. La utilización de expresiones regulares se incluye a partir de la versión 1.4 del JDK.
1 public class ExMatriculaValidar {
2 private boolean UnaLetra(String Matricula) {
4 return Matricula.substring(0,1).matches("[A-Za-z]");
5 }
6 public void Validar(String Matricula) throws ExMatricula {
8 if (Matricula.length()!=8) 
9 throw new ExMatricula(ExMatricula.MAL_TAMANIO);
10else
11if (!UnaLetra(Matricula))
12throw new ExMatricula(ExMatricula.MAL_LETRA);
13else
14{} // matricula bien formada      
15}
16}

Con el método de validación de matrículas implementado, capaz de levantar la excepción  ExMatricula, ya podemos escribir una aplicación que recoja las matrículas que introducen los usuarios. La recuperación de los errores de formato se escribirá en el bloque catch correspondiente: 

1  public class ExMatriculaPrincipal {
2     public static void main (String[] args) {
3       ExMatriculaValidar LaMatricula = new ExMatriculaValidar();
5       do 
6        try {
7          System.out.println("Introduce la matricula: ");
8          String Matricula = Teclado.Lee_String();
9          LaMatricula.Validar(Matricula);
10        }
11        catch(ExMatricula e) {
12          switch (e.DimeProblema()) {
13            case ExMatricula.MAL_TAMANIO:
14              System.out.println("Tamanio incorrecto");
15              break;
16            case ExMatricula.MAL_LETRA:
17              System.out.println("Letra inicial no incluida");
18              break;
19            default:
20              System.out.println("Matricula correcta");
21             break; 
22          }
23        }
24       while(true);
25     }
26  }

En el código anterior existe un bucle  infinito (líneas 5 y 24) que permite la validación de matrículas (líneas 7, 8 y 9). Habitualmente estas tres líneas se ejecutan repetitivamente; esporádicamente el usuario introducirá una matrícula con el formato erróneo y el método Validar levantará la excepción ExMatricula, que será recogida y tratada en el bloque catch (línea 11).
En la línea 12 sabemos que se ha producido una excepción  ExMatricula, pero no conocemos su causa exacta (tamaño incorrecto o primer carácter distinto de letra). El método DimeProblema que incluimos en la clase ExMatricula nos indica el estado de la excepción. Si el estado de la excepción es  MAL_TAMANIO le indicamos esta situación al usuario que introdujo la matrícula con un tamaño incorrecto (líneas 14 y 15). En las líneas 17  y 18 hacemos lo propio con MAL_LETRA.
La ventana siguiente muestra un ejemplo de ejecución del programa:

Los objetos utilizados en el ejemplo se presentan en la siguiente tabla

La estructura de clases se representa en el siguiente diagrama que relaciona los objetos: 

1 comentario: