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.
Me gusta:
Sé el primero en decir que te gusta esta post.
