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.
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:
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
Top Related