Download Resumen Manejo de Excepciones

Resumen Manejo de Excepciones
Excepción
Excepción es un cierto tipo de error o una condición anormal que se ha producido durante la
ejecución de un programa. El nombre de excepción viene del hecho de que, es un problema que
ocurre con poca frecuencia; si la regla es que una instrucción se ejecuta de forma correcta,
entonces la e x c e p c i ó n a l a r e g l a es cuando ocurre un problema. En Java una excepción es un
objeto que avisa que ha ocurrido un cierto tipo de error o una condición anormal durante la
ejecución de un programa. Java dispone de una jerarquía de clases que permiten crear objetos de
excepciones.
Fuente: Aprenda Java como si estuviera en Primero. Universidad de Navarra. 1999
La clase Error está relacionada con errores de compilación, del sistema o de la JVM (Java Virtual
Machine).
La clase Exception es la superclase de todas las excepciones que se presentan en los programas
en tiempo de ejecución.
Manejo de excepciones
El manejo de excepciones permite a los programadores crear p r o g r a m a s
robustos
y
t o l e r a n t e s a f a l l a s , que lanzan o manejan las excepciones. En muchos casos el manejo de una
excepción, permite que el programa continúe su ejecución como si no se hubiera encontrado el
problema.
Los errores relacionados con errores de compilación, del sistema o de la JVM, s o n
i r r e c u p e r a b l e s y no dependen del programador ni debe preocuparse de capturarlos y tratarlos.
El manejo de excepciones está diseñado para procesar errores que ocurren cuando se ejecuta una
instrucción. Las excepciones en tiempo de ejecución ocurren cuando el programador no ha tenido
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.
2
Excepciones
cuidado al escribir su código. Por ejemplo, cuando se sobrepasa la dimensión de un arreglo se
lanza una excepción ArrayIndexOutOfBounds. Cuando se hace uso de una referencia a un objeto
que no ha sido creado se lanza la excepción NullPointerException. Estas excepciones le indican
al programador que tipos de fallos tiene el programa y que debe arreglarlo antes de proseguir.
Java permite l a n z a r o m a n e j a r l a s e x c e p c i o n e s .
Lanzar una excepción
En Java puede considerarse una excepción como un segundo tipo de valor que puede devolver un
método en caso de que exista una situación anormal durante la ejecución del método. Para lanzar
una excepción, un método debe crear un objeto de la clase Exception o de alguna subclase de
Exception y utilizar la instrucción throw (la instrucción throw es parecida a la instrucción
return). Además debe especificar en la cabecera del método, que puede lanzar la excepción
usando la instrucción throws. El siguiente código muestra como crear y lanzar un objeto
Exception cuando el método dividir trata de dividir por cero.
Avisa que puede
lanzar una excepción
public static int dividir(int num, int den) throws Exception{
if (den == 0)
throw new Exception(“División por cero”);
else
return num/den;
}
Lanza una excepción
En vista de que el método dividir puede lanzar una excepción, cualquier método que lo llame a
él d e b e lanzar o capturar la excepción lanzada por el método dividir. Similar a un juego de
beisbol (baseball), un jugador lanza la pelota y el que la recibe la captura o la lanza de nuevo.
Otro ejemplo de un método que lanza una excepción es el método parseInt de la clase Integer:
public static int parseInt(String s)throws NumberFormatException
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.
3
Excepciones
Capturar una excepción
Para capturar una excepción Java proporciona el bloque:
try{
//aquí se coloca el código del programa que puede producir una excepción
}catch(Exception obj){
Se declara un objeto del tipo de la clase de
Excepción que se está capturando
//aquí se coloca el código que el programa debe ejecutar cuando capture la excepción
}finally{
/* aquí se coloca el código que el programa debe ejecutar ocurra o no ocurra la excepción
por ejemplo, cerrar un archivo */
}
El siguiente código muestra como el método dividir captura la excepción que puede ser lanzada
por el método dividir.
/**En caso de que el método dividir lance una excepción
* de división por cero, el método dividirVector
* la captura y la maneja, NO la lanza
*/
public void dividirVector(double x[], int y[]){
int i = 0;
try{
for(;i < x.length; i++)
x[i] = dividir(x[i], y[i]);
}catch (Exception obj){
System.out.println("getMessage = "+ obj.getMessage()+ "\ntoString = " + obj);
System.out.println("Traza del stack = ");obj.printStackTrace();
System.out.println("Error en la posición i= "+i);
}
}
Nota: si dentro de un bloque try{} se producen varios tipos de excepciones, se puede colocar un
catch para cada una o colocar un solo catch y recibir un objeto de la clase Exception que es la
superclase de todas las excepciones.
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.
4
Excepciones
Para visualizar como Java maneja el lanzamiento y captura de excepciones usaremos la clase
ManejoExcepciones
y
CapturandoExcepciones.
dos
Java
main
class
PruebaLanzandoExcepciones
/*
* ManejoExcepciones.java
* Created on 17 de mayo de 2006, 11:05 AM
* autor
M. Fátima De Abreu
*/
package CompAvanz12006.Unidad2.excepciones;
public class ManejoExcepciones {
public ManejoExcepciones() {
}
/** método que divide a/b sin verificar
* que b sea diferente de cero*/
public double dividir(int a, int b) {
return (double)a/b;
}
/** método que lanza una excepción
* cuando ocurre la division por cero*/
public double dividir(double a, int b) throws Exception{
if (b == 0)
throw new Exception("División por cero");
else
return a/b;
}
/** En caso de que el método dividir lance una excepción
* de división por cero, el método dividirVector se la lanza
* al método que lo llamó
*/
public void dividirVector(double x[], int a)throws Exception{
for(int i = 0; i < x.length; i++)
x[i] = dividir(x[i], a);
}
/**En caso de que el método dividir lance una excepción
* de división por cero, el método dividirVector
* la captura y la maneja, NO la lanza */
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.
y
Prueba
5
Excepciones
public void dividirVector(double x[], int y[]){
int i = 0;
try{
for(;i < x.length; i++)
x[i] = dividir(x[i], y[i]);
}catch (Exception obj){
System.out.println("getMessage = "+ obj.getMessage()+ "\ntoString = " + obj);
System.out.println("Traza del stack = ");obj.printStackTrace();
System.out.println("Error en la posición i= "+i);
}
}
}
public class PruebaLanzandoExcepciones {
public PruebaLanzandoExcepciones() {
}
El método main lanza cualquier
excepción que le lancen a el
public static void main(String[] args) throws Exception {
ManejoExcepciones obj = new ManejoExcepciones();
System.out.println("division 4/0
= " + obj.dividir(4,0));
System.out.println("division 4.0/0 = " + obj.dividir(4.0,0));
double x[]={1,2,3,4};
int y[] = {1,2,0,4};
System.out.println("\nProbando con los vectores\n");
obj.dividirVector(x,y);
obj.dividirVector(x,0);
System.out.println("\nProbando con los vectores 66666666666666\n");
}
}
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.
6
Excepciones
public class PruebaCapturandoExcepciones {
public PruebaCapturandoExcepciones() {
}
main
captura
y
maneja
cualquier excepción que reciba
public static void main(String[] args) {
try{
ManejoExcepciones obj = new ManejoExcepciones();
System.out.println("division 4/0
= " + obj.dividir(4,0));
System.out.println("division 4.0/0 = " + obj.dividir(4.0,0));
System.out.println("\nProbando con los vectores\n");
double x[]={1,2,3,4};
int y[] = {1,2};
obj.dividirVector(x,y);
obj.dividirVector(x,0);
}catch(Exception obj){
System.out.println("Exceptio\n"+obj);
}
}
}
Java tiene muchos objetos de excepción predefinidos, y también podemos crear los nuestros
propios.
Crear nuevas clases de Excepciones
El programador puede crear sus propias excepciones sólo con heredar de la clase Exception o de
una de sus clases derivadas. Lo lógico es heredar de la clase de la jerarquía de Java que mejor se
adapte al tipo de excepción. Las clases Exception suelen tener dos constructores:
1. Un constructor sin argumentos.
2. Un constructor que recibe un String como argumento. En este String se suele definir un
mensaje que explica el tipo de excepción generada. Conviene que este constructor llame al
constructor de la clase de la que deriva super(String).
Al ser clases como cualquier otra se podrían incluir variables y métodos nuevos. Por ejemplo:
class MiExcepcion extends Exception {
public MiExcepcion() { // Constructor por defecto
super();
}
public MiExcepción(String s) { // Constructor con mensaje
super(s);
}
}
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.
7
Excepciones
Las clases java.lang.Throwable y sus Subclases
Throwable
Error
LinkageError
ClassCircularityError
ClassFormatError
ExceptionInInitializerError
Por heredar de Throwable todos
los tipos de excepciones pueden
usar los métodos siguientes:
String getMessage()
Extrae el mensaje asociado con la
IncompatibleClassChangeError
excepción.
AbstractMethodError
IllegalAccessError
String toString()
InstantiationError
NoSuchFieldError
Devuelve un String que describe la
NoSuchMethodError
NoClassDefFoundError
excepción.
UnsatisfiedLinkError
VerifyError
void printStackTrace()
VirtualMachineError
InternalError
Indica la traza de los métodos
OutOfMemoryError
donde se lanzó la excepción.
StackOverflowError
UnknownError
ThreadDeath
Exception
ClassNotFoundException
CloneNotSupportedException
IllegalAccessException
InstantiationException
InterruptedException
RuntimeException
ArithmeticException
ArrayStoreException
ClassCastException
IllegalArgumentException
IllegalThreadStateException
NumberFormatException
IllegalMonitorStateException
IndexOutOfBoundsException
NegativeArraySizeException
NullPointerException
SecurityException
IOException
EOFException
FileNotFoundException
InterruptedIOException
UTFDataFormatException
AWTException
Referencias:
http://java.sun.com/docs/books/tutorial/essential/exceptions/throwable.html
http://java.sun.com/docs/books/jls/first_edition/html/javalang.doc20.html#46198
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2006.