excepciones -...

Excepciones

M.C. Yolanda Moyao Martínez

Excepción

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

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

Ventajas

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

Propagar los errores sobre la pila de llamadas.

Desde el primer método que llamo a los diversos métodos hasta que lleguemos al error.

Agrupar errores y clasificar

Errores

Representan situaciones de error

normalmente no recuperables

El programador normalmente no tiene que proporcionar un tratamiento para ellas

Ejemplos

No se puede localizar y cargar una clase

Se agota la memoria

Excepciones

Predefinidas en el sistema

Se lanzan automáticamente cuando se realiza alguna operación no valida

Acceso a un objeto que no existe

Acceso a una posición de un array que no existe

División por cero

Excepciones

Generadas por el programador

El programa explícitamente genera una excepción al detectar una situación de error que no se puede resolver en ese contexto

Útil en situaciones de prueba y depuración

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”).

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.

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 Excepciones2 {

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 nuestros propios errores personalizados.

Sintaxis

try{ //Este código puede lanzar 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. Libera recursos

Ejemplo 1 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.

Ejemplo sentencias catch múltiples

class MultiCatch{

public static void main (String args[]){

try {

int a = args.length;

System.out.println(“a=”+a);

int b=42/a;

int c[]={1};

c[42]=99;

} catch(ArithmeticException e){

System.out.println(“División por 0:”+e);}

catch(ArrayIndexOutOfBounsException e){

System.out.println(“Indice fuera de límite”+e);}

System.out.println(“Después de try/catch”);

}}

Clase excepcion

Proporciona algunos métodos de utilidad, por ejemplo

printStackException

Muestra el volcado de pila con todos los métodos que están siendo llamados en el momento en el que se lanzó el error:

Volcado de la pila

Ejemplo

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

{

excepcion.printStackTrace();

}

Generando excepciones-usuario

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);

} }

Constructores ------excepciones

Todas las excepciones que están en el núcleo de Java tienen 2 constructores:

Uno sin parámetros

Otro que tiene un parámetro de tipo cadena

throw –lanzar un error

public class Try5 {


try {

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

throw e; }

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

} } }

Ejecución

java.lang.Exception: Este es mi propio error.

at Try5.main(Try5.java:4)

Process completed.

Clase personalizada y throw

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

public class Try7 {


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

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

Ejecución

MiPropioError: Este es mi propio error.


Process completed.

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 Try6 {


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

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

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

Ejecución

java.lang.Exception: Este es mi propio error.


Se ejecuta finally

Jerarquía de clases

Una subclase debe estar antes que su superclase en una serie de sentencias catch.

Si no se produce un error en la compilación “código inalcanzable”

Ejemplo

class SuperSubCatch {

public static void main(String args[]){

try{

int a=0;

int b = 42/a;

}

catch (Exception e){

System.out.println("sentencia catch para cualquier tipo de exception");

}

/* esta sentencia catch nunca se ejcutará ya que ArithmeticException es una subclase de Exception*/

catch(ArithmeticException e) {// ERROR no alcanzable

System.out.println("esto nunca se ejecuta");

}}}

Practica 12

Hacer un programa que maneje cuentas de un banco con las opciones de capturar datos de cuenta y clientes y transferencia de dinero.

Utiliza excepeciones para cancelar la transferencia si no hay fondos

Tarea 12. ejecutar la excepciónpublic 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 3 métodos de las subclases de Exeption

Hacer un programa usando cada uno de los métodos

excepciones -...

Documents