RSS

Archivos Mensuales: enero 2012

Control del Flujo: Excepciones

Excepción

Es un evento excepcional que altera el flujo normal del programa. Cuando esto ocurre decimos que se ha lanzado una excepción.

Una excepción se puede generar:

  • en la JVM, como respuesta a una condición inesperada (Caso 1).
  • en el código, lanzadas explícitamente por el programador utilizando la sentencia throw (Caso 2).

Las excepciones del primer caso se llaman no comprobadas (unchecked) y las del segundo comprobadas (checked).

Ejemplo Caso 1: No comprobadas.
Por ejemplo, al intentar acceder a una posición inválida en un array.

public class PruebaOutOfBounds {
    public static void main (String[] args){
        int[] notas = new int[5];
        for (int i = 0; i<=5; i++){
            notas[i] = i*2;
            System.out.println("notas["+i+"]=" + notas[i]);
        }
    }
}

Otras excepciones no comprobadas son: ArithmeticException, ClassCastException, NullPointerException, …
En general son aquellas que descienden de la clase RuntimeException.


Ejemplo Caso 2: Comprobadas.

Cuando lanzamos explícitamente una excepción.

...
 public void reverse() throws Exception{
    if (nombre == null){
       throw new Exception ("El nombre es nulo.\n Lanzamos excepcion al intentar hacer
                             reverse().");
    }
    else
    {
        for (int i = nombre.length()-1; i >=0; i --)
            System.out.println(nombre.charAt(i));
    }
}
...

En general son aquellas que descienden de la clase Exception, excluyendo RuntimeException.


Regla del Manejo o la Declaración
Las excepciones comprobadas que un método pueda lanzar se deben declarar.

Si se produce una excepción comprobada en el código, el método debe:

  • manejar la excepción utilizando el bloque try-catch-finally
  • ó declarar la excepción y pasar la responsabilidad de declaración o gestión al método llamante.

Para declarar la excepción se utiliza la sentencia throws.

Manejando Excepciones
El manejo de excepciones en Java se lleva a cabo principalmente mediante las sentencias: try, catch y finally.

try{
.... //Código que puede provocar una excepcion
}
catch (Excepcion1){   //Puede haber 0, 1 o muchos bloques catch.
       //En caso de haber 0 debe existir bloque finally.
....
}
finally{  //Puede haber 0 o 1 bloque finally.
....   //En caso de haber 0 debe existir bloque catch.
}

En el bloque try encerramos el código que puede lanzar una excepción.
En el bloque catch definimos qué excepción y con qué código tratarla.
En el bloque finally escribimos código que siempre se ejecuta se produzca o no la excepción.

Ejemplo:

public class Alumno{
//...
   public static void main (String[] args){
        try{
         Alumno a = new Alumno("Ana", 12, 6);
         System.out.println(a);
         a.reverse();

         Alumno c = new Alumno();
         System.out.println(c);
         c.reverse();

       }
       catch (Exception e) {
           System.out.println("--> Hemos capturado la excepcion!!.");
       }
       finally {
           System.out.println("--> Siempre se ejecuta se produzca o no excepcion.");
       }
  }
}

Restricciones de los bloques try-catch-finally:

  • Un bloque try debe tener un bloque catch o un bloque finally asociado.
  • Entre un bloque try y catch no puede escribirse código.
  • Si hay varios bloques catch las excepciones más específicas deben colocarse antes que las más generales.
Anuncios
 
2 comentarios

Publicado por en 10 enero, 2012 en Estudio, Tema 5

 
 
A %d blogueros les gusta esto: