Excepciones
Programación Orientada a Objetos
(POO)
Excepciones
03/14/202 2
4
¿Cual es el problema con este
método?
public double dividir(int numerador, int denominador)
{
return numerador/denominador;
}
¿Qué regresa el método si se pasa como argumentos (3, 0)?
public long factorial(int n) {
if (n==0)
return 1;
return n * factorial(n - 1);
}
¿Qué regresa el método si se pasa como argumento -3?
03/14/202 3
4
Posible solución
public long factorial(int n) {
if (n < 0)
return -1;
if (n == 0)
return 1;
return n * factorial(n - 1);
}
Un valor regresado por el método esta indicando un código de
error.
¿Qué pasa si un desarrollador no sabe que un factorial no puede ser
negativo?
03/14/202 4
4
Excepciones
Excepción: evento anormal o excepcional que requiere un procesamiento
especial.
La mayoría de lenguajes OO (Java, C++, C#, Python, etc.) incluyen
mecanismos explícitos de manejo de excepciones.
En lugar de retornar un valor indicado un error, «lanzan» una excepción para
indicar esta situación.
El código que invoca al método donde la excepción es lanzada puede tomar
acciones para «remediar» el problema.
03/14/202 5
4
Solución recomendada
public long factorial(int n) throws FactorialException {
if (n < 0)
throw new FactorialException("factorial indefinido
para numero negativo") ;
if (n==0)
return 1;
return n * factorial(n - 1);
}
El método «lanza» una excepción para indicar que el evento
excepcional ocurrió-
03/14/202 6
4
Las Excepciones en Java
En Java las excepciones son objetos.
Cuando una situación anormal (error) ocurre, el método crea un
objeto de tipo excepción y lo «lanza».
Esta instancia contiene información acerca del problema que acaba
de ocurrir.
Esta información incluye el tipo de error y el estado del programa en
el momento en que ocurre.
En Java las clases para representar excepciones están organizadas
en una jerarquía.
Es posible crear sus propias clases de excepciones.
03/14/202 7
4
Solución recomendada
public long factorial(int n) throws FactorialException {
if (n < 0)
throw new FactorialException("factorial indefinido
para numero negativo") ;
if (n==0)
return 1;
return n * factorial(n - 1);
}
La excepción que se lanza es una instancia de la clase
FactorialException
03/14/202 8
4
Jerarquía Excepciones en Java
Throwable
Error Exception
RuntimeException
NullPointerException IOException
IndexOutOfBoundException SQLException
ClassCastException MalformedURLException
… …
03/14/202 9
4
Las Excepciones en Java
Toda excepción en Java contiene
Un atributo de tipo String para almacenar el mensaje de error.
Un método getMessage() que permite acceder a este mensaje.
Es posible personalizar el mensaje de una excepción al momento
de la creación de la instancia:
FileNotFoundException exc = new FileNotFoundException("El
archivo " + nombreArc + " no fue encontrado");
03/14/202 10
4
Crear una clase de Excepción
Heredar de la clase java.lang.Exception
public class FactorialException extends Exception {
public FactorialException(String mensaje) {
super(mensaje);
}
03/14/202 11
4
Lanzar una Excepción
Es responsabilidad del método lanzar la excepción cuando detecta una
anomalía.
Cuando un método desea lanzar una excepción debe declarar esta intención
usando la palabra clave throws
Para lanzar una excepción el método debe:
Crear una instancia de un tipo de excepción declarado en el método.
Lanzar la excepción usando la palabra clave throw
03/14/202 12
4
Lanzar una Excepción
public long factorial(int n) throws FactorialException {
if (n < 0)
throw new FactorialException("factorial indefinido
para numero negativo") ;
if (n==0)
return 1;
return n * factorial(n - 1);
}
03/14/202 13
4
Propagación de excepciones
Si una excepción es lanzada la JVM interrumpe la ejecución normal
del programa.
La excepción es propagada del código llamado (método invocado)
hacia el código que hace la invocación (método invocador).
Si se encuentra un bloque try-catch la excepción es tratada en ese
bloque y la ejecución continua normalmente después de ese
bloque.
Si no encuentra un bloque try-catch, la excepción es propagada
hacia el siguiente método invocador.
Si llega al método main sin encontrar quien la trate el programa
termina y la excepción se muestra en la consola.
03/14/202 14
4
Propagación de excepciones
Principal
main( )
Alfa Beta
m1( ) m2( )
Gama
m3( )
03/14/202 15
4
Tratamiento de excepciones
Las excepciones se dividen entre controladas y no controladas.
Para las excepciones controladas el desarrollador esta obligado a tratarlas.
Tratar una excepción se realiza de dos formas:
Delegando al método invocador el tratamiento.
Gestionando la excepción dentro del propio método.
Para delegar la excepción se agrega la declaración con la palabra clave
throws
Para gestionar la excepción se utiliza la estructura try/catch/(finally)
03/14/202 16
4
Delegación
Principal
main( )
Alfa Beta
m1( ) *m2( )
Gama
*m3( )
El método m2 delega el
tratamiento a aquellos
métodos que lo invoquen
03/14/202 17
4
Delegando al método invocador
public long factorial(int n) throws FactorialException {
…
}
public void testDelegar(int n) throws FactorialException {
System.out.println("El factorial de " + n + " es:");
long fact = factorial(n);
System.out.println(fact);
System.out.println("La ejecucion continua aqui");
}
03/14/202 18
4
Delegación de la excepción
Principal1
*main( )
CalculoFactorial CalculoFactorial
*testDelegar( ) *factorial( )
03/14/202 19
4
Gestionando Excepciones
ESTRUCTURA TRY-CATCH-FINALLY
Try: código a vigilar, puede lanzar una excepción.
Catch: código que tratara la excepción si esta ocurre.
Finally: código de limpieza, siempre se ejecuta.
try {
// Código a vigilar
} catch (TipoExcepcion e) {
// Código para tratar la excepción
} finally {
// Código de limpieza
}
03/14/202 20
4
Gestionando la excepción
public long factorial(int n) throws FactorialException {
…
}
public void testGestionar(int n) {
System.out.println("El factorial de " + n + " es:");
try {
long fact = factorial(n);
System.out.println(fact);
} catch (FactorialException e) {
System.out.println("Problema " + e.getMessage());
}
System.out.println("La ejecucion continua aqui");
}
03/14/202 21
4
Gestión de la excepción
Principal2
*main( )
CalculoFactorial CalculoFactorial
testGestionar( ) *factorial( )
03/14/202 22
4
Estructura try-catch-finally
Un bloque puede capturar diferentes tipos de excepciones.
Cuando se captura una excepción de un tipo dado se
gestionan también todos sus subtipos.
Solo existe una sección finally
try {
// Codigo a vigilar
} catch (TipoExcepcion1 e) {
// Codigo para tratar la excepcion TipoExcepcion1
} catch (TipoExcepcion2 e) {
// Codigo para tratar la excepcion TipoExcepcion2
} finally {
// Codigo de limpieza 03/14/202 23
} 4
Ventajas del tratamiento de excepciones
Separar el código «normal» del código dedicado al tratamiento
de situaciones excepcionales (errores).
Una separación y clasificación de los tipos de errores que se
pueden presentar.
Poder propagar errores en la pilla de llamados de los métodos.
03/14/202 24
4
"Para que pueda surgir lo posible. Es preciso intentar una y otra
vez lo imposible". (Hermann Hesse)
