Manejo de excepciones - Pontificia Universidad Javeriana

Manejo de Excepciones
M. Consuelo Franky – Julio Carreño
Pontificia Universidad Javeriana
1
Temario
 Captura de excepciones
 Excepciones estándares
 Cómo provocar una excepción
 Cómo definir nuevas excepciones
 Propagación de excepciones
2
1.
Captura de excepciones
3
Qué pasa si no se capturan excepciones?
Mensajes poco
amistosos con el
usuario cuando
hay problemas
4
Capturando una Excepción
Mensajes
amistosos con el
usuario cuando
hay problemas
5
La captura de excepciones permiten
una programación clara
 El flujo normal de operaciones se separa del
tratamiento de errores
 Evita tener que chequear códigos de error después de
cada operación
 Captura de la excepción más general :
try {
procesarDatos();
mostrarResultados(); // no se realiza si hay
// error en procesarDatos
}
catch (Exception e) {
tratamientoErrores();
}
6
Flujo de control try/catch
Acciones al capturar la excepción
 Se interrumpe la operación del try que produjo la
excepción y se realizan las operaciones especificadas
en el catch
 No se realizan más operaciones del try
 Operaciones típicas en el catch de una excepción e
System.out.println (“hubo un error” + e.getMessage());
System.err.println (e.toString()); //clase de excepcion
// y descripcion
e.printStackTrace(); // pila de invocaciones
return; // si se quiere terminar el actual metodo
System.exit(-1); // si se quiere terminar el programa
8
Captura de varias posibles excepciones
try {
procesarDatos();
mostrarResultados();
}
catch (IOException e) {
tratamientoErroresIO();
}
catch (ArithmeticException e) {
tratamientoErroresAritmeticos();
}
catch (Exception e) {
cualquierOtroError();
}
finally { //de todas maneras se hace esta parte:
//despues de trat. normal o de excepcion
cerrarArchivos();
}
Observar el finally : se ejecuta haya o no haya excepción.
Declarar variables antes del try para poderlas usar en todas las secciones (por ej: la
variable archivo)
9
Flujo de control del bloque finally
try / catch / finally anidados
2.
Excepciones estándares
12
Todas las excepciones son subclases
de Exception

ClassNotFoundException

IOException
• EOFException
• FileNotFoundException
• MalformedURLException
• UnknownHostException
• SocketException

RuntimeException
• ArithmeticException
• IndexOutOfBoundsException
• NullPointerException
• SecurityException
y muchas más...
13
Las excepciones son capturables, los
errores no
Tipos de Excepciones
3.
Cómo provocar una excepción
15
Definir un método que provoque una
excepción cuando haya una
condición anormal
 Ejemplo: no admitir información de un empleado cuya
cédula esté fuera de rango:
public class Empleado {
String nombre;
long cedula;
public void setNombre (String n) {
this.nombre = n;
}
public void setCedula (long c) throws Exception {
if (c>0 && c <= 99999999)
this.cedula = c;
else
throw new Exception (“cedula fuera de rango”);
;
}
}
Observar: throw new para lanzar la excepción
y throws en el encabezado del método
16
 Invocación del método que provoca la excepción : lo
hace dentro de un try-catch
Empleado s = new Empleado ();
try {
s.setNombre ("Pedro Perez");
s.setCedula (415556666);
}
catch (Exception e) {
System.out.println (e.getMessage());
}
17
4.
Cómo definir nuevas excepciones
18
Definir una nueva excepción
 Permite definir excepciones apropiadas para la
aplicación
 Definición como subclase de otra excepción :
public class ExcepcionCedula extends Exception {
private String mensaje;
ExcepcionCedula (String s) {
mensaje = s;
}
public String toString () {
return "ExcepcionCedula " + mensaje;
}
}
19
 Provocar la nueva excepción :
public class Empleado {
String nombre;
long cedula;
public void setNombre (String n) {
nombre = n;
}
public void setCedula (long c)
throws ExcepcionCedula {
if (c < 0 )
throw new ExcepcionCedula ("cedula negativa");
else if ( c > 99999999)
throw new ExcepcionCedula ("cedula muy grande");
else
cedula = c;
;
}
}
20
Las excepciones definidas por el
programador pueden tener varios atributos

Permite personalizar los mensajes y mostrar información
más útil sobre la excepción
this.minimo = min;
this.maximo = max;
• el constructor debe asignar min y max a los atributos
• toString() puede mostrar el mensaje, el minimo y el maximo
5.
Propagación de una excepción
22
 La responsabilidad de capturar una excepción se puede
transferir al que invoca el método que produce la
excepción (propagar hacia atrás):
1
Aplicacion
(test)
ingresarEmp
2
setCedula
3
Empleado
Novedades
catch
throws
throw new
y
throws
Una excepción puede ser :
- lanzada (throw new)
- propagada hacia atrás (throws)
- manejada (catch)
23
 ejemplo:
1
public class Test{
public static void main (String[] args){
Novedades nov = new Novedades();
try {
nov.ingresarEmp("Pedro Perez", 415556666);
}
catch (ExcepcionCedula e) {
System.out.println (e.toString());
}
catch (Exception e) {
e.printStackTrace();
}
...
}
}
24
2
3
public class Novedades {
void ingresarEmp (String nombre, long cedula)
throws ExcepcionCedula {
Empleado s = new Empleado ();
s.setNombre ("Pedro Perez");
s.setCedula (415556666);
}
}
public class Empleado {
String nombre; long cedula;
public void setNombre (String n) {
nombre = s;
}
public void setCedula (long c)
throws ExcepcionCedula {
if (c < 0 )
throw new ExcepcionCedula ("cedula negativa");
else if ( c > 99999999)
throw new ExcepcionCedula ("cedula muy grande");
else
cedula = c;
;
}
}
25
 Un método puede provocar varias clases de excepciones :
void ingresarEmp (String nombre, long cedula)
throws ExcepcionCedula, ExcepcionNombre {
....
}
 Un método puede provocar una excepción y capturar otra :
public void setCedula (long c) throws ExcepcionCedula {
try {
long maxCedula = leerCedulaMaxima();
if (c>0 && c <= maxCedula)
cedula = c;
else
throw new ExcepcionCedula (“cedula errada”);
;
}
catch (IOException e) {
System.out.println (“no pudo leer maxCedula”);
}
}
Buena práctica: solo el Test captura excepciones para informar al usuario
26
 Ejemplo 2: propagación de excepciones con objetos
Chance que se quieren grabar en disco
1
agregarChance()
TestTeclado
3
2
grabarChance()
Chance
Operador
catch
throws
throws
grabarChance()
throw new IOException
4
y
throws
Grabador
27
Otro ejemplo de Propagación de Excepciones
clase Test
clase LecturaDatos
Manejadores y propagadores de
excepciones
En una cadena de invocaciones toda excepción propagada hacia atrás debe ser
capturada por alguna de las clases iniciales en la cadena
6.
Esquema de los métodos que
trabajan con archivos
(clase ManejoArchivos)
30
 Objetivo: asegurar el cierre de archivos y al mismo
tiempo propagar toda posible excepción al Test


Debe usar try catch para poder cerrar los archivos en el finally
Todo catch lanza una excepción propia PersistenceException que es
propagada al Test
public static void cargarArchivo(Iempresa empresa,
String nombreArchivo) throws PersistenciaException{
File arch = null;
FileInputStream fis = null;
try{
arch = new File("./" + nombreArchivo);
fis = new FileInputStream(arch);
Scanner in = new Scanner(fis);
//TODO: procesar el archivo
}
catch(FileNotFoundException e){
throw new PersistenciaException
("El archivo no existe " + e.getMessage());
}
catch ( Exception e){
throw new PersistenciaException
("Ocurrio un error leyendo el archivo " + e.getMessage());
}
finally{
try {
fis.close();
} catch (IOException e) {
throw new PersistenciaException
("Ocurrio error cerrando el archivo "+e.getMessage());
}
}
31
}
 Excepción PersistenceException:
public class PersistenciaException
extends Exception {
public PersistenciaException(String arg) {
super(arg);
}
}
32
Ejercicio
 Defina una enumeración TipoResultado para los posibles resultados de operaciones
bancarias: EXITO, FRACASO, NO _HAY_FONDOS, NO_EXISTE
 Defina una enumeracion TipoMovimiento para los posibles movimientos sobre una
cuenta bancaria: CONSIGNACION, RETIRO
 Cada Cuenta tiene como atributos: codigo y saldo y una constante de clase que indica
cuál debe ser el saldo mínimo. El constructor de Cuenta recibe codigo y saldo inicial y
debe provocar una excepción cuando el saldo inicial es menor que el saldo mínimo. El
método realizarMovimiento no debe dejar el saldo de una cuenta por debajo del saldo
mínimo y debe retornar el resultado EXITO o NO_HAY_FONDOS
 Modele una clase Banco que tiene como atributos su nombre y una lista de Cuentas.
Como métodos tiene: agregarCuenta, realizarMovimiento; este último recibe como
parámetros el código de la cuenta, el tipo de movimiento y el monto y puede retornar
como resultado EXITO, NO_HAY_FONDOS, NO_EXISTE (la cuenta).
 Escriba un TestTeclado que instancie un objeto Banco y le agregue varias cuentas .
Debe capturar la excepción cuando trata de instanciar una cuenta con saldo inicial por
debajo del saldo mínimo e informarle al usuario.
 El TestTeclado también debe capturar excepción cuando el usuario suministra letras para
datos numéricos e informar al usuario el error.
 El TestTeclado luego puede hacer movimientos sobre las cuentas indicando al usuario el
resultado.
33