View
232
Download
1
Category
Preview:
Citation preview
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 {
public static void main(String arg[]) {
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 {
public static void main(String arg[]) {
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.
at Try7.main(Try7.java:3)
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 {
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"); } } }
Ejecución
java.lang.Exception: Este es mi propio error.
at Try6.main(Try6.java:3)
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
Recommended