¿Qué es el Manejo de Excepciones?
El manejo de excepciones es un mecanismo de algunos lenguajes de programación, que permite definir acciones a realizar en caso de producirse una situaciones anomala (excepción) producida durante la ejecución del programa.
La acción a realizar suele consistir en una acción correctiva, o la generación de un informe acerca del error producido.
Ejemplos de lenguajes con gestión de excepciones son Java, Net, C++, Objective-C, Ada, Eiffel, y Ocaml.
Como se implementa?
Los lenguajes con gestión de excepciones incorporan en sus bibliotecas la capacidad de detectar y notificar errores.
Cuando un error es detectado se siguen estas acciones:
1. Se interrumpe la ejecución del código en curso.
2. Se crea un objeto excepción que contiene información del problema. Esta acción es conocida como "lanzar una excepción".Existe un mecanismo estandar de gestión de error
3. Si hay un manejador de excepciones en el contexto actual le transfiere el control. En caso contrario, pasa la referencia del objeto excepción al contexto anterior en la pila de llamadas.
4. Si no hay ningún manejador capaz de gestionar la excepción, el hilo que la generó es terminado.
2. Se crea un objeto excepción que contiene información del problema. Esta acción es conocida como "lanzar una excepción".Existe un mecanismo estandar de gestión de error
3. Si hay un manejador de excepciones en el contexto actual le transfiere el control. En caso contrario, pasa la referencia del objeto excepción al contexto anterior en la pila de llamadas.
4. Si no hay ningún manejador capaz de gestionar la excepción, el hilo que la generó es terminado.
Por ejemplo, si intentamos leer un fichero inexistente usando la clase FileReader del lenguaje Java, la implementación de la propia clase detectará el problema, y lanzará una excepción de tipo FileNotFoundException.
Por qué es importante usar excepciones?
El código de tratamiento del error está separado del resto del programa. Esto aumenta la legibilidad y permite centrarse en cada tipo de código.
Un mismo manejador puede gestionar las excepciones de varios ámbitos inferiores. Esto reduce la cantidad de código necesaria para gestionar los errores.
Existe un mecanismo estandar de gestión de error. Lenguajes anteriores como C empleaban el retorno de valores especiales en cada método para señalar condiciones anomalas. Esto implicaba que a cada llamada debía seguirle un código de gestión de errores que enturbiaba la legibilidad del código.
Implementación en Java
La captura de excepciones se implementa en el lenguaje Java con el bloque try/catch/finally. El capítulo 9 de Thinking in Java es una excelente introducción al tema (que vale la pena leer aunque seas un programador senior).
try {
código sospechoso de producir excepciones
} catch(Excepcion e){
// registra el error y/o relanza la excepción
} finally {
// libera recursos
}
La excepción a capturar puede ser cualquier subclase de Throwable.
El código del finally se ejecutará siempre. Una excepción en el try, o en el bloque catch no impedirán su ejecución.
Si el bloque finally lanza una excepción, quedarán descartadas excepciones anteriores. Es decir, una excepción en el finally oculta excepciones anteriores.
Throwable
Throwable es la superclase de todos los objetos excepción:
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
Según su superclase, hay dos tipos de excepciones:
Checked: el programa no compila si no existe un manejador de excepciones. Son las subclases de Exception que no son subclases de RuntimeException.
Unchecked: su captura no es obligatoria. Son las subclases de RuntimeException.
Un ejemplo completo
El siguiente programa realiza la división entera de dos números pasados por consola:
import java.math.BigInteger;
public class Main {
private static void usage(){
System.out.println("USAGE: java Main number1 number2");
}
static void divide(String a, String b){
try {
BigInteger bi1 = new BigInteger(a);
BigInteger bi2 = new BigInteger(b);
System.out.println( bi1.divide(bi2) );
} catch (NumberFormatException e2) {
System.err.println("Not a number! " + e2.getMessage());
usage();
}
}
public static void main(String[] args) {
divide(args[0],args[1]);
}
} [1]
Generar Excepciones
Cuando se produce un error se debería generar, o lanzar, una excepción. Para que un método en Java, pueda lanzar excepciones, hay que indicarlo expresamente.
void MetodoAsesino() throws NullPointerException,CaidaException
Se pueden definir excepciones propias, no hay por qué limitarse a las predefinidas; bastará con extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa excepción.
También pueden producirse excepciones no de forma explícita como en el caso anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no válida.
También pueden producirse excepciones no de forma explícita como en el caso anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no válida.
throw ObtejoExcepction;
El objeto ObjetoException es un objeto de una clase que extiende la clase Exception .
El siguiente código de ejemplo origina una excepción de división por cero:
class melon {
public static void main( String[] a ) {
int i=0, j=0, k;
k = i/j; // Origina un error de division-by-zero}
}
}
Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente salida por pantalla:
> javac melon.java
> java melon
java.lang.ArithmeticException: / by zero
at melon.main(melon.java:5)
Las excepciones predefinidas, como ArithmeticException , se conocen como excepciones runtime. Actualmente, como todas las excepciones son eventos runtime, sería mejor llamarlas excepciones irrecuperables. Esto contrasta con las excepciones que generamos explícitamente, que suelen ser mucho menos severas y en la mayoría de los casos podemos recuperarnos de ellas. Por ejemplo, si un fichero no puede abrirse, preguntamos al usuario que nos indique otro fichero; o si una estructura de datos se encuentra completa, podremos sobreescribir algún elemento que ya no se necesite.[2]
Excepciones Predefinidas
Las excepciones predefinidas y su jerarquía de clases es la que se muestra en la figura:
Los nombres de las excepciones indican la condición de error que representan. Las siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar:
ArithmeticException
Las excepciones aritméticas son típicamente el resultado de una división por 0:
int i = 12 / 0;
NullPointerException
Se produce cuando se intenta acceder a una variable o método antes de ser definido:
class Hola extends Applet {
Image img;
paint( Graphics g ) {
g.drawImage( img,25,25,this );
}
}
IncompatibleClassChangeException
El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados.
ClassCastException
El intento de convertir un objeto a otra clase que no es válida.
y = (Prueba)x;
// dondex no es de tipo Prueba
NegativeArraySizeException
Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array.
OutOfMemoryException
¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema.
NoClassDefFoundException
Se referenció una clase que el sistema es incapaz de encontrar.
ArrayIndexOutOfBoundsException
Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un array más allá de los límites definidos inicialmente para ese array.
UnsatisfiedLinkException
Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método a.kk
class A {
native void kk();
}
InternalException
Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca debería ver este error y esta excepción no debería lanzarse. [3]
BIBLIOGRAFIA CONSULTADA
No hay comentarios:
Publicar un comentario