Excepciones

M.C. Yolanda Moyao Martínez

Ventajas

Separar el manejo de errores del código “normal”.

Propagar los errores sobre la pila de llamadas.

Desde la primera función que llamo a las diversas funciones hasta que lleguemos al error.

Agrupar errores y diferenciación

Excepción

Cuando un programa viola las restricciones semánticas del lenguaje (se produce un error)

La máquina virtual Java comunica este hecho al programa mediante una excepción

Evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias.

Catch Exception

En el momento en que es lanzada una excepción, la máquina virtual Java recorre la pila de llamadas de métodos en busca de alguno que sea capaz de tratar la clase de excepción lanzada.

Errores----Excepción

Hardware

Disco duro

Desbordamiento de memoria

Errores de programación

Elementos de un arreglo fuera de rango

Operaciones no permitidas

Throw

Cuando ocurre lo anterior, la máquina virtual Java crea un objeto de la clase exception o error y se notifica el hecho al sistema de ejecución.

Se dice que se ha lanzado una excepción (“Throwing Exception”).

Ejemplo

public class error{

public static void main(String[] arg)

{ int diez[]= new int[10];

diez[12]=10;}

Exception in trhead “main” java.lang.ArrayIndexOutOfBoundsException:12 at error.main(main.java:7)

Ejemplo

public class Excepciones1 {

public static void main(String[] arg)

{ metodo(); }

static void metodo() {

int divisor = 0;

int resultado = 100/divisor;

System.out.println(“Resultado: ” + resultado);

System.out.println(“Una Suma:” + (3+4));

}}

Al ejecutar

Exception in thread "main" java.lang.ArithmeticException: / by zero

at Excepciones2.metodo(Excepciones2.java:7)

at Excepciones2.main(Excepciones2.java:3)

Process completed.

Descripción

la máquina virtual Java ha detectado una condición de error y ha creado un objeto de la clase java.lang.ArithmeticException.

El método donde se ha producido la excepción no es capaz de tratarla

Se trata por la máquina virtual Java, que muestra el mensaje de error anterior y finaliza la ejecución del programa.

Jerarquía de excepciones

Excepciones-problemas

En java disponemos de un mecanismo consistente en el uso de bloques try/catch/finally

Los tipos de error que se generan son todos ellos clases, que heredan de la clase java.lang.Exception

Por lo tanto podríamos crear nuestro propios errores personalizados.

Sintaxis

try{ //Este código puede generar una

excepción }

catch(Exception ex){ //Este código se

ejecuta cuando se produce una excepción

}

finally{ //Este código se ejecuta se

produzca o no una excepción }

Zonas

try, o zona de pruebas, donde pondremos las instrucciones problemática.

una o más zonas catch, cada una especializada en un tipo de error o excepción.

zona finally, encargada de tener un código que se ejecutará siempre, independientemente de si se produjeron o no errores.

Ejemplo public class Try3 {

public static void main(String arg[]) {

int [] array = new int[20];

try { // array[-3] = 24;

int b = 0;

int a = 23/b; } catch(ArrayIndexOutOfBoundsException excepcion) {

System.out.println(" Error de índice en un array"); } catch(ArithmeticException excepcion) {

System.out.println(" división por cero"); } } }

se ejecuta el catch correspondiente al tipo de error generado.

Clase excepcion

Proporciona algunos métodos de utilidad, por ejemplo

printStackException

Muestra el volcado de pila con todas las funciones que están siendo llamadas en el momento en el que se lanzó el error:

Ejemplo

try { array[-3] = 24; } catch(Exception excepcion)

{

excepcion.printStackTrace();

}

Generación de excepciones

Para que se pueda lanzar una excepción es necesario crear un objeto de tipo Exception o alguna de sus subclases como ArithmeticException y lanzarlo mediante la instrucción throw

class LanzaExcepcion {public static void main(String argumentos[]) //throws ArithmeticException

{

int i=1, j=2;

if (i/j< 1)

throw new ArithmeticException();

else

System.out.println(i/j);

} }

throw –lanzar un error

public class Try5 {

public static void main(String arg[]) {

try {

Exception e = new Exception("Este es mi propio error.");

throw e; }

catch(Exception excepcion) { excepcion.printStackTrace();

} } }

Clase personalizada y throw

public class Try6 {

public static void main(String arg[]) {

try { MiPropioError e = new MiPropioError("Este es mi propio error."); throw e; }

catch(Exception excepcion) { excepcion.printStackTrace(); } } }

class MiPropioError extends Exception{ public MiPropioError(String mensaje){ super(mensaje); } }

Finally-libera recursos

Dentro de try solicitamos recursos y trabajamos con ellos

La única manera de liberar recursos independientemente de si se lanza una excepción o no

Consiste en emplear una claúsula finally, que será ejecutada siempre, haya o no haya lanzamiento de excepciones.

Ejemplo

public class Try7 {

public static void main(String arg[]) {

try { Exception e = new Exception("Este es mi propio error."); throw e; }

catch(Exception excepcion) { excepcion.printStackTrace(); }

finally { System.out.println("Se ejecuta finally"); } } }

Tareapublic class ExcepcionApp {

public static void main(String[] args) {

String str1="12";

String str2="0";

String respuesta;

int numerador, denominador, cociente;

try{

numerador=Integer.parseInt(str1);

denominador=Integer.parseInt(str2);

cociente=numerador/denominador;

respuesta=String.valueOf(cociente);

}catch(NumberFormatException ex){

respuesta="Se han introducido caracteres no numéricos";

}catch(ArithmeticException ex){

respuesta="División entre cero";

}

System.out.println(respuesta); }}

Investigar para que sirve Throws