Excepciones

Excepciones
FJP – Unidad 12
Excepciones
Una excepción es la representación de una
condición de error o cualquier situación no
esperada en el resultado de un método.
Son instancias de subclases de la clase
Throwable
Java incluye un conjunto de excepciones estándares que
pueden ser disparadas automáticamente
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
1
Objetos Excepciones
Jerarquía de clases Throwable
Cada objeto de estas clases poseen atributos privados que mantienen
información de la excepción o error generado.
Métodos: getMessage( ), printStackTrace(0); (heredados de Throwable)
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Capturando excepciones
Identificar en un método toda excepción que no sea de la
clase o subclase de Error o RuntimeException
Si un programador desea manipular una excepción en un
método:
ubicar el código que puede potencialmente generar la
excepción en un bloque try – catch
Un método puede poseer varios bloques try, y varios bloques catch por
cada bloque try
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
2
Capturando excepciones
((cont.)
cont.)
El bloque catch captura la excepción y posee el
código para tratarla
try {
// código que puede lanzar excepciones...
}
catch (IOException ioe) {
// código para manipular excepciones de entrada salida
}
catch (Exception e) {
// código para manipular otras excepciones
}
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Lanzando excepciones
Existen al menos tres formas de lanzar una
excepción:
A través de un método
el cual es declarado como potencial disparador de un tipo de excepción
también puede relanzarla
Excepción en tiempo de ejecución (RunTimeExceptions)
Como parte de la lógica del negocio
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
3
Lanzando excepciones ((cont.)
cont.)
Si el programador no desea manipular una excepción, sino
pasarla hacia arriba en la pila de llamada:
se debe declarar en la signatura del método utilizando la
cláusula:
throws
<tipo de sub-class Throwable>
Un método puede disparar múltiples excepciones
utilizando la sintaxis:
throws <tipo de sub-class Throwable, tipo de sub-class
Throwable, ...>
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Ej. Lanzando y Capturando
excepciones
public void unMetodo(String s, int x) throws CustomException,
Exception {
Boolean conditiontest = false;
try {
// lanza excepción IOException
Posible excepción
char c = (char) System.read( ) ;
if (alguna condición !!!)
conditiontest = true;
}
catch (IOException e) {
throw new Exception(“Existe un problema con su teclado,
verifique el cable”);
}
if (!conditiontest)
{
throw new CustomException(“Condición falsa”);
}
int x = 15 /0;
// esto lanzará una excepción aritmética
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
4
Bloque finally
Un bloque finally siempre será ejecutado
Puede ser utilizado para contener código que debe ser
ejecutado después de un bloque try, o antes debido a la
ocurrencia de una excepción
Ej.:
try {
cli.manipularCliente();
}
catch (MiExcepcion me)
{
System.out.println(me.getMessage());
}
finally
{
// este código se ejecuta ocurra o no ocurra la excepción
// ...
}
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Reglas para trabajar con
excepciones
El compilador fuerza la manipulación de todas las
excepciones definidas
¾ Deben ser capturadas y especificadas
¾ No es necesario capturar y especificar excepciones y
errores que surgen en tiempo de ejecución
No es posible capturar una excepción que no sea de la
misma clase o subclase de la excepción disparada
Pueden extenderse excepciones a partir de la clase
Exception
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
5
Reglas para trabajar con
excepciones ((cont.)
cont.)
Herencia de métodos:
¾ No es posible sobreescribir métodos y lanzar
excepciones diferentes a las del método de clase padre.
¾ Es posible lanzar menos excepciones que las del método
de la clase padre
¾ Es posible lanzar excepciones que sean subclases de las
excepciones del método de la clase padre
¾ No es posible lanzar excepciones más generales que las
excepciones del método de la clase padre
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Reglas para trabajar con
excepciones ((cont.)
cont.)
Múltiples bloques catch pueden ser utilizados
para capturar diferentes tipos de excepciones
Las cláusulas catch deben estar en secuencia:
- Primero los tipos de excepciones más derivados
- Último los tipos más básicos o menos derivados (cercanos a la raíz
de la jerarquía)
No debe ubicarse código entre el bloque try y el bloque
catch, o entre los bloques catch
No es posible tener un bloque try sin un bloque catch
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
6
Excepción
no manejada
Excepción
no manejada
Extensión de la pila de llamadas
Pila de llamadas
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Excepciones definidas por el
usuario
Tres pasos para crear y utilizar excepciones
definidas por el usuario
1. Crear una clase que extienda de Exception
2. En un método de otra clase, lanzar (“throw”) una nueva
instancia de la excepción
3. Usar el método que dispara la excepción en un bloque
try - catch
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
7
Clase de excepciones
definidas por el usuario
public class MyException extends Exception{
// atributos
String nameofobject;
int valueofobject;
//constructor
public MyException(String message, String s, int x) {
super(message);
nameofobject =s;
valueofobject =x;
}
// sobreescribe getMessage incluyendo inf. acerca del objeto
public String getMessage( ) {
return super.getMessage() + “Object information is :” +
nameofobject + “ “ + valueofobject;
}
// otros métodos
} // fin de la clase
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
Utilizar la excepción en un
método de alguna clase
public class Customer {
// atributos
String custname;
int custid;
// constructor
public Customer (String name, int id){
custname = name;
custid = id;
}
// setter and getter methods...
//custom method
public void handleCustomerIssue( ) throws MyException
{
// lógica...
// verificación de una condición
{
throw new MyException(“Customer at fault”, custname, custid);
}
// otro código...
} // fin del método
} // fin de la clase
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
8
Manejo de excepciones
definidas por el usuario
public class MyApp{
public static void main(String[] args) {
Customer cust = new Customer(“Kim Lee”, 34567);
// otro código e invocación de otros métodos...
try {
cust.handleCustomerIssue();
}
catch (MyException me) {
System.out.println(me.getMessage());
}
} // fin del método main
} // fin de la aplicación
Academia Local Cisco – UTN Facultad Regional Santa Fe – http://www.santafecna.org.ar
9