Excepciones en el lenguaje Java

Las excepciones (Exceptions) son un mecanismo del lenguaje Java que facilita que el
desarrollador maneje condiciones excepcionales, que normalmente estn asociadas a
fallos, dentro de sus programas. Existen un conjunto de excepciones predefinidas
dentro de la AP estndar de Java, pero el desarrollador puede definir sus propias
excepciones si lo desea. Para comprender qu! es " c#mo se maneja una excepci#n, lee
detenidamente los siguientes puntos.
Las excepciones de Java son clases (soportan $erencia, polimorfismo, etc.) que
$eredan de otra excepci#n
Existe una jerarqu%a predefinida de clases de excepci#n cu"a ra%& es la clase
Throwable
'na instancia (o(jeto) de una de estas clases puede ser )lan&ada) dentro de un
programa a trav!s de la sentencia throw
'na ve& que una excepci#n se $a lan&ado, el flujo natural de ejecuci#n del
programa se detiene en el instante en que produce la llamada a throw, de modo,
que la excepci#n se propaga por la pila del programa, desde los llamados $acia los
llamantes, interrumpiendo la ejecuci#n de todos ellos.
La *nica manera de detener la propagaci#n de una excepci#n que $a sido lan&ada
es a trav!s de un manejador de excepciones
+i una excepci#n no se maneja en ninguna parte de la cadena de propagaci#n,
terminar deteniendo el programa (o el thread) en el que se $a lan&ado
El manejador de excepciones en Java tiene la sintaxis siguiente,
try{

//Aqu est el cdigo que puede lanzar excepciones
...
} catch !lase"e#a$xcepcion ob%eto$xception& {
...
//Aqu est el cdigo que se e%ecutar si se lanza una excepcin del
//tipo !lase"e#a$xcepcin
...
}
Para comprender con precisi#n el manejo de excepciones, o(serva el ejemplo
siguiente,
-ic$ero, EjemploExcepciones.java
public class $%e'plo$xcepciones {
public static (oid 'ain)tring*+ args& {
i, args.length -. /&
)yste'.out.println0"ebe introducir un entero a la entrada0&1
int entero#eido . stringTo2ntargs*3+&1
)yste'.out.println04a introducido el entero 0 5 entero#eido&1
}
pri(ate static int stringTo2nt)tring entero& {
int resultado . 2nteger.parse2ntentero&1
return resultado1
}
}
Prue(a a compilar " ejecutar el programa, vers que transforma la cadena de
caracteres que le indiquemos como argumento en un entero,
6 %a(ac $%e'plo$xcepciones.%a(a
6 %a(a $%e'plo$xcepciones /789
4a introducido el entero /789
Prue(a a$ora a introducir una cadena de caracteres que no corresponda con el formato
de ning*n entero,
6 %a(a $%e'plo$xcepciones el:ato
$xception in thread 0'ain0 %a(a.lang.;u'ber<or'at$xception= <or input
string= 0el:ato0
at %a(a.lang.;u'ber<or'at$xception.,or2nput)tring
;u'ber<or'at$xception.%a(a=9>&
at %a(a.lang.2nteger.parse2nt2nteger.%a(a=99?&
at %a(a.lang.2nteger.parse2nt2nteger.%a(a=9@?&
at $%e'plo$xcepciones.stringTo2nt$%e'plo$xcepciones.%a(a=/8&
at $%e'plo$xcepciones.'ain$%e'plo$xcepciones.%a(a=>&
.omo puedes o(servar, la mquina virtual $a detectado que )el/ato) no tiene el
formato de ning*n entero ", por ese motivo, $a elevado una excepci#n en el m!todo
esttico parse2nt de la clase 2nteger, que est en el paquete %a(a.lang de la
AP estndar. Esa excepci#n se $a propagado a nuestro m!todo esttico
stringTo2nt " desde a$% al m!todo main. .omo ninguno de esos m!todos
implementa(a un manejador de excepciones, el programa $a terminado por detenerse.
maginemos a$ora que modificamos el programa del modo siguiente,
public class $%e'plo$xcepciones {
public static (oid 'ain)tring*+ args& {
i, args.length -. /&
)yste'.out.println0"ebe introducir un entero a la entrada0&1
try{
int entero#eido . stringTo2ntargs*3+&1
)yste'.out.println04a introducido el entero 0 5 entero#eido&1
} catch ;u'ber<or'at$xception e& {
)yste'.out.println0#a cadena 0 5 args*3+ 5 0 no es un entero.
Ten 's cuidado la prxi'a (ez0&1
}
)yste'.out.println0Ahora el progra'a puede continuar0&1
}
pri(ate static int stringTo2nt)tring entero& {
int resultado . 2nteger.parse2ntentero&1
return resultado1
}
}
En este caso, al ejecutar o(tenemos lo siguiente,
6 %a(ac $%e'plo$xcepciones.%a(a
6 %a(a $%e'plo$xcepciones el:ato
#a cadena el:ato no es un entero. Ten 's cuidado la
prxi'a (ez
Ahora el progra'a puede continuar
.omo puedes o(servar, la excepci#n se $a vuelto a producir en la llamada a
2nteger.parse2ntentero&, de a$% se $a propagado al m!todo
stringTo2nt, que no tiene manejador de excepciones, por lo que $a seguido
propagndose $asta llegar al m!todo 'ain. En !ste, dado que la invocaci#n que $a
producido la excepci#n est dentro de un (loque try{...}, la excepci#n no se $a
propagado, sino que se el flujo de ejecuci#n del programa $a saltado al (loque
catch{...} correspondiente. 0ras lo cual, el programa $a continuado con una
ejecuci#n normal.
Checked and Unchecked Exceptions
En Java existen dos familias de excepciones, cada una de las cuales requiere un
tratamiento espec%fico por parte del programador, las excepciones que en la
documentaci#n de Java se denominan Checked " las que se denominan Unchecked.
La traducci#n de estos t!rminos al castellano dentro de este contexto es am(igua, pero
podr%amos decir que las excepciones Checked son las que requieren control por parte
del llamante " las Unchecked no lo requieren. 1amos a explicar ms en detalle en qu!
consiste esta distinci#n,
Las excepciones Checked $eredan de la clase $xception de Java
Las excepciones Unchecked $eredan de la clase Aunti'e$xception de Java
Los m!todos que pueden lan&ar una excepci#n Checked (ajo alguna circunstancia,
de(en indicarlo en su declaraci#n
Los m!todos que pueden lan&ar una excepci#n Unchecked (ajo alguna
circunstancia, no lo indican en su declaraci#n
2(serva que, en Java, un m!todo que invoca una llamada que puede lan&ar una
excepci#n Checked tiene dos opciones, o (ien implementar un manejador de la
excepci#n o (ien indicar en su declaraci#n que !l tam(i!n puede elevar la citada
excepci#n. 3e este modo, el compilador o(liga al programador a que reflexione so(re
si es ms conveniente manejar la excepci#n o declararse como un m!todo que las
eleva. En principio, las excepciones Checked son aquellas que se producen por
motivos ajenos al programador (es decir, se pueden dar en un programa correcto que
se $a encontrado con una situaci#n inesperada). Las excepciones Checked son
comunes cuando se tra(aja con operaciones de entrada4salida, manejo de fic$eros, etc.
Por otro lado, las excepciones Unchecked suelen reservarse para condiciones de fallo
que estn asociadas a errores en el c#digo, es decir, a errores del desarrollador. Por
ejemplo, la excepci#n ;ullBointer$xception, se eleva cuando un programa
trata de acceder a alg*n m!todo o atri(uto de un o(jeto que contiene una referencia a
null.
Esta clasificaci#n indica el esp%ritu, pero no es rigurosa, prue(a de ello es el ejemplo
que $emos proporcionado en la secci#n precedente, en la que se muestra que
;u'ber<or'al$xception es una excepci#n Unchecked, pero se podr%a dudar de
que, en este caso, el pro(lema pueda considerarse responsa(ilidad del programador.
En cualquier caso, de(es recordar que cuando tra(ajes con m!todos de la AP estndar
que sean suscepti(les de elevar excepciones Checked de(es, o (ien declarar tus
m!todos como suscepti(les de elevarlas, o (ien implementar un manejador apropiado
para las mismas.
El siguiente ejemplo muestra el aspecto de dos m!todos que deciden tomar cada una
de las estrategias descritas para excepciones .$ec5ed.
class $xcepcion!hecCed extends $xception{}
class $xcepcionDnchecCed extends Aunti'e$xception{}
public class $%e'plo$xcepciones {
public static (oid 'ain)tring*+ args& {
'etodoDno&1
try{
'etodo"os&1
} catch$xcepcion!hecCed e&{
)yste'.out.printlne.getEessage&&1
e.print)tacCTrace&1
}
'etodoTres&1
}
public static (oid 'etodoDno&{
try{
puede#anzar!hecCed&1
} catch $xcepcion!hecCed e& {
)yste'.out.printlne.getEessage&&1
e.print)tacCTrace&1
}
}
public static (oid 'etodo"os& throws $xcepcion!hecCed{
puede#anzar!hecCed&1
}
public static (oid 'etodoTres&{
puede#anzarDnchecCed&1
}
public static (oid puede#anzar!hecCed& throws
$xcepcion!hecCed{
throw new $xcepcion!hecCed&1
}
public static (oid puede#anzarDnchecCed& {
throw new $xcepcionDnchecCed&1
}
}
Ejercicio final
.rea un programa en java que tenga las siguientes caracer%sticas,
6a(r una clase denominada Brincipal que contendr el m!todo 'ain por
el que la J17 comien&a el flujo de ejecuci#n de un programa
Al ejecutar Brincipal aparecer un men* que permitir al usuario
introducir nuevos alumos desde el teclado. Para cada alumno se de(e
especificar, asignatura, nom(re, apellidos, 38, edad, " las notas
correspondientes a la normativa de esa asignatura.
6a(r que implementa un m%nimo de 9 asignaturas con normativas diferentes.
Para cada asignatura definida, los alumnos introducidos se almacenarn en una
ta(la $as$ (4ashtable).
El men* de usuario que imprimir el programa principal permitir (uscar, para
cada asignatura, un alumno por 38 e imprimir los datos del alumno
encontrado por pantalla.
.ada ve& que se introdu&ca un alumno " sus notas, $a(r que reali&ar los
c$equeos siguientes
o Los nom(res " apellidos comien&an por ma"*sculas
o La edad es num!rica " comprendida entre :; " :;;
o Las notas respetan la normativa. As%, por ejemplo, en la asignatura +0<
la nota de teor%a es un n*mero de coma flotante comprendido entre
;.; " = " la nota de prcticas es un n*mero de coma flotante
comprendido entre ;.; " =.;
+i alguno de estos c$equeos no se valida, el m!todo set correspondiente
elevar una excepci#n de tipo $xcepcion"eAlu'no que ser >c$ec5ed?.
En el m!todo 'ain se capturarn todas las excepciones " se incluir un
manejador que imprima un mensaje de error comprensi(le por el usuario. 0ras
esto se permitir que el usuario vuelva a intentar reali&ar la operaci#n.
.ualquier otra excepci#n que pueda surgir durante la ejecuci#n del programa
ser manejada de la manera que el alumno considere ms conveniente.