Download excepciones - WordPress.com

EXCEPCIONES
CORPORACION UNIVERSITARIA DEL CARIBE CECAR
PROGRAMA DE INGENIERIA DE SISTEMAS
LENGUAJES DE PROGRAMACION II
INTRODUCCION
 En la programación hay algo que siempre ocurre:
los errores en los programas.
¿qué sucede
realmente
después de
que ha
ocurrido el
error?
¿Qué
podemos
hacer con
él?
¿Cómo nos
damos
cuenta que
se ha
producido?
 Java utiliza excepciones para el manejo de los errores.
Por ejemplo…
¿Qué
sucede si
no se
puede abrir
el fichero?
¿Qué
sucede si no
se puede
cerrar el
fichero?
¿Qué
sucede si
la lectura
falla?
¿Qué sucede
si no se puede
determinar la
longitud del
fichero?
¿Qué sucede
si no hay
suficiente
memoria
libre?
¿Que hacer?
Ignorar que los
errores pueden
ocurrir
Utilizar
bloques if…else
Usar
excepciones
¿Qué es una excepción?
 Es un evento que ocurre durante la ejecución del
programa que interrumpe el flujo normal de las
sentencias
 Es una condición anormal ocurrida durante la
ejecución de un programa
 No necesariamente es un error
 Comportamiento no adecuado o no permitido
Ventajas de usar excepciones
Separar el Manejo de Errores del Código
"Normal“.
• Simplifican los programas ya que se diferencia el código
normal del código de tratamiento de errores
Programas mas robustos
• Se crean programas mas robustos ya que en muchos casos si
no se trata la excepción el programa no compila
Agrupar Errores y Diferenciación.
• Gracias a esto tenemos todos los posibles errores juntos y
podemos pensar una manera de tratarlos que sea adecuado.
Tipos errores y de excepciones
Compilación
Tipos de excepciones
Tipos de
errores
Ejecución
(Excepciones)
Fatales
provocan la terminación
inmediata de un programa en
ejecución.
Recuperables
pueden ser manipuladas, es
decir, existe la posibilidad de
corregirlas y continuar con la
ejecución del programa
Excepciones en Java
 Cuando ocurre una excepción, se crea un objeto que
contiene toda la información acerca de ésta.
 El interpretador (JVM) debe encontrar el código para
manejarla (lanzar la excepción).
 Si existe un código definido para el tipo de excepción,
este código atrapa la excepción.
 Si no existe código definido para este tipo de excepción,
el programa se termina.
Jerarquía de excepciones en Java
¿Qué se puede hacer con las excepciones?
 Tratar con las Excepciones Java


Gestionar la excepción
Re-lanzar la excepción
 Crear nuevas Excepciones
Tratando excepciones en Java
 El compilador de Java, indica cuando debemos gestionar una
excepción o lanzarla.

FileOutputStream.java:15: Warning: Exception java.io.IOException must be
caught, or it must be declared in throws clause of this method.
 Gestionar la excepción
 try, catch, y finally
 Para gestionar excepciones hay que insertar el código donde se puede
dar dentro de un bloque try.
 Se crea una lista de bloques catch adyacentes, uno por cada posible
excepción.
Manejador de excepciones
 El manejo de una Excepción en Java, se realiza a través
de las palabras reservadas:

try : Las instrucciones contenidas en un bloque try, lanzarán la
excepción si ésta ocurre.

catch: Atrapa la excepción lanzada y la maneja.

throw: lanza la excepción en el momento deseado.

throws: lanza la excepción fuera del método.

finally: instrucciones que siempre se ejecutan.
Lanzar Excepciones (try)
 Cuando en un método es probable que se produzca
una situación anómala, es necesario lanzar una
excepción y para ello se utiliza el bloque try.
 Sintaxis:
try {
//sentencias que se desea controlar
}
Atrapar Excepciones (catch)
 Las excepciones pueden ser capturadas y gestionadas en el
mismo método que las lanzó o en otro lugar del programa.
 Para atrapar la excepciones en el propio método se utiliza la
instrucción catch.
 Sintaxis:
catch (excepción objeto){
// sentencias para manejar la excepción
}
 Se debe escribir inmediatamente después del bloque try.
 Puede haber varios bloques catch para un bloque try, y cada bloque catch
manejará un tipo de excepción.
Bloque try-catch
try {
....
} catch (exception 1) {
...
} catch (exception 2) {
…
} catch (exception 3) {
}
...
Ejemplo del bloque try… catch
public class PruebaExcepciones {
public static void main(String args[]) {
int valor=5, cero=0;
int[] array = {1, 2, 3};
try {
valor = valor/cero; //división por cero
array[4]= 5; //acceso a una posición no
//disponible
}
catch( ArithmeticException e ) {
System.out.println( "Division por cero" );
}
catch( Exception e ) {
System.out.println( "Se ha producido un error" );
}
}
}
Bloque finally
 Este bloque es opcional y debe ir después de todos los bloques catch
implementados.
 Si se incluye, sus sentencias se ejecutan siempre, sea cual sea el tipo de
excepción que se produzca, o incluso si no se produce ninguna (se
ejecuta incluso si dentro de los bloques try/catch hay una sentencia
continue, break o return).
 La única situación en la que la sentencia finally no se ejecuta es si se
llama al método System.exit (), que termina la ejecución del
programa.
 El bloque finally se debe utilizar particularmente en aquellos casos en
que, se necesita recuperar o devolver a su situación original algunos
elementos (objetos, recursos).
Sintaxis del bloque finally
try {
// Código que puede
} catch (A a1) {
// Se ocupa de la
} catch (B b1) {
// Se ocupa de la
} catch (C c1) {
// Se ocupa de la
} finally {
// Sentencias que
}
lanzar una excepción de tipo A, B o C
excepción A
excepción B
excepción C
se ejecutarán en cualquier caso
Bloque throw
 La sentencia throw (lanzar) se puede emplear para
indicar que ha ocurrido una excepción,
particularmente cuando se quiere lanzar una
excepción propia.
 throw requiere un simple argumento: un objeto de
la clase Throwable, esta clase tiene dos subclases
principales: Exception y Error.
Propagación de excepciones
Entorno Java
(java runtime)
Llamada a
los métodos
Método main()
Primer método
Segundo método
(Excepción generada aquí)
Paso de
excepciones
Relanzar Excepciones - throws
 En ciertos casos, cuando un método puede generar
una situación anómala, y no se desea manipular la
excepción en el código del propio método, es posible
que se pase o se “relance” la excepción al método
invocador, para ello se utiliza la sentencia throws.
 Sintaxis:
void metodo() throws excepcion{
// Código que puede lanzar las excepciones
...
} // fin del método
Excepciones propias
 La clase Exception, normalmente tiene dos
constructores.
 Ejemplo:
public class MiExcepcion extends Exception{
public MiExcepcion()
{ super(); }
public MiExcepcion(String cadena)
{ super(cadena); }
} // fin de la clase
Ejemplo excepciones de java
public class Alumno
{
private String nombre , private String apellido, private Integer edad;
public Alumno(String nombre, String apellido, Integer edad) throws Exception
{
this.nombre = nombre;
this.apellido = apellido;
if (edad <= 0){
throw new Exception("La debe edad ser mayor a cero");
}else{
this.edad = edad;
}
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public Integer getEdad() {
return edad;
}
}
public class Test {
public static void main (String []arguments){
try {
Alumno alu1 = new Alumno("Marcos", "Fernandez", -2);
} catch (Exception e) {
system.out.println(e.getMessage());
}
}
}
Ejemplo excepciones propias
public class InvalidYearException extends Exception {
public YearInvalidException(String mensaje){
super(mensaje);
}
}
public class Alumno {
private String nombre, String apellido, Integer edad;
public Alumno(String nombre, String apellido, Integer edad) throws InvalidYearException {
this.nombre = nombre;
this.apellido = apellido;
if (edad <= 0){
throw new InvalidYearException("La edad debe ser mayor a cero");
}else{
this.edad = edad;
}
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public Integer getEdad() {
return edad;
}
}
public class Test {
public static void main(String []arguments){
try {
Alumno alu1 = new Alumno("Marcos", "Fernandez", -2);
} catch (InvalidYearException e) {
System.out.println("Se atrapo una excepcion del tipo InvalidYearException");
System.out.println(e.getMessage());
}
}
}