Excepción

Excepción
Una excepción es una condición anormal que se produce en una
sentencia de código a tiempo de ejecución. En otras palabras, una excepción
es un error en tiempo de ejecución. Una excepción Java es un objeto que
describe una condición excepcional (esto es, error) que ha ocurrido a un
segmento de código. Cuando surge una condición excepcional, se crea un
objeto que representa una excepción y se lanza (throw) en el método que
produce el error. El manejo de excepciones se gestiona mediante cinco
palabras reservadas: try, catch, throw, throws y finally.
Si al momento de ejecutar un programa ocurre un error, Java lanza una
excepción, es un soporte que proporciona para el manejo de errores.
Las excepciones en Java son objetos de subclases de Throwable que
está definida en el paquete java.lang. Las excepciones se tienen que capturar
y manejar para que se pueda reanudar la ejecución del programa.
Manejo de excepciones
Para capturar una excepción se tiene que escribir el bloque que puede
generar un error dentro de try y para manejar esa excepción se utiliza catch
como se muestra a continuación:
try
{
// Código de la aplicación
}
catch(clase_de_excepción e)
{
//Código de tratamiento de esta excepción
}
catch (otra_clase_de_excepción e)
{
//Código de tratamiento para otra clase de excepción
}
finally{
//Código
}
Un bloque try puede estar seguido de uno o más bloques de catch.
Cada catch debe tener un parámetro de la clase Throwable o de alguna
subclase de ésta. Cuando se lance una excepción, el bloque catch que lo
atrape será aquel cuyo parámetro sea de la clase o de una superclase de la
excepción.
Clase de excepción
Bloque de finalización
Si se desea realizar alguna acción por obligación como cerrar un
archivo, liberar algún recurso externo que se haya adquirido, etc., se debe
poner el código adecuado dentro de un bloque finally después del bloque try o
de un bloque catch. El bloque finally debe ser siempre el último.
La ejecución del bloque finally queda garantizada independientemente
de que finalice o no la ejecución del bloque try. Los bloques try y finally se
pueden utilizar conjuntamente sin que sea necesario incluir un bloque catch.
Declarar excepciones
La palabra reservada throws permite a un método declarar las listas de
excepciones ( nombres de las clases de excepción separados por comas) que
pueden lanzar. Esto tiene dos lecturas:
1.- Dar información a los usuarios de la clase que proporciona este método
sobre
las
cosas
anormales
que
puede
hacer
el
método.
2.-Escribir un método que lance una o más excepciones que no sean atrapadas
por el propio método, sino por los métodos que lo llamen.
Crear y lanzar excepciones
En Java podemos crear nuestras propias excepciones. Todos los tipos
de excepción se corresponden con una clase derivada de Throwable, clase
raíz de la jerarquía de clases de excepciones de Java. El paquete java.lang
proporciona dos subclases de Throwable que agrupan las excepciones que se
pueden lanzar, como consecuencia de los errores que pueden ocurrir en un
programa, en dos clases: Error y Exception. Los errores que ocurren en la
mayoría de los programas se corresponden con excepciones de alguna de las
subclases de ExceptionError reservada para el tratamiento de los errores que
se puedan producir en la máquina virtual de Java.
Ejemplo:
public class EValorNoValido extends Exception
{
public EValorNoValido() {}
public EValorNoValido(String mensaje)
{
super(mensaje);
}
}
Estamos utilizando la clase anterior para crear una excepción para un
error no valido, la superclase es Exception e implementa dos constructores,
uno sin parámetros y otro con un parámetro de tipo String. El parámetro de
tipo String es el mensaje que devolverá el método getMessage heredado de la
clase Throwable a través de Exception. Para ello el constructor
EValorNoValido debe invocar al constructor de la superclase y pasar como
argumento dicha cadena, la cual será almacenada como un miembro de datos
de la clase Throwable.
Ejemplo de aplicación
public class MiClase
{
public void n(int x)
{
if(x==0)
throw new EValorNoValido("Error: valor cero");
}
}
Lanzar una excepción equivale a crear un objeto de ese tipo de
excepción. En este ejemplo lo que provoca el error es que el parámetro x del
método n de MiClase es 0, en este caso el método n lanza una excepción de
la clase EValorNoValido creando un objeto de esta clase. Para crear (new)
ese objeto se invoca al constructor EValorNoValido pasando como argumento,
en este caso, la cadena "Error:valor cero";
Si un método n lanza una excepción debe declararlo, para que los
usuarios de MiClase, que es quien proporciona el método n, estén informados
sobre las cosas anormales que puede hacer dicho método.
public class MiClase
{
public void n (int x) throws EValorNoValido
{
if (x==0)
throw new EValorNoValido("Error: valor cero");
}
}
Otra alternativa es que el propio método que lanza la excepción la atrape
como se muestra en el siguiente ejemplo:
public class CMiClase
{
public void n(int x)
{
try
{
if(a==0)
throw new EValorNoValido("Error: valor cero");
}
catch(EValorNoValido e )
{
System.out.println(e.getMessage());
}
}
}
Escribir un método que lance una o más excepciones y él mismo las
atrape es anticiparse a las necesidades que pueda tener el usuario de la clase
que proporciona ese método, en cuanto al tratamiento de la excepción se
refiere.
Ejemplo
public class PruebaExcepcion{
public static void main(String [] args){
int [] a ={0,1,2,3,4,5};
try{
for (int i=0;i<6;i++){
System.out.println(“a[“+i+”]es “+a[i]);
}
}
catch(excepcion e) {
System.out.println(“Excepcion: “ +e);
}
System.out.println(“Código que se puede ejecutar”);
} }