Libro

TEMA 5. EXCEPCIONES EN JAVA............................................................
1
5.1 DEFINICIN DE EXCEPCIONES EN PROGRAMACIN.........................2
5.2 TIPOS DE EXCEPCIONES / ERRORES Y CMO TRATARLOS.............10
5.3 TRABAJANDO CON EXCEPCIONES: DECLARACIN, CONSTRUCCIN,
LANZAMIENTO Y GESTIN DE EXCEPCIONES ................................. 14
5.3.1 PROPAGACIN DE EXCEPCIONES...............................................15
5.3.2. CAPTURA Y GESTIN DE EXCEPCIONES....................................18
5.3.3CAPTURA, GESTIN Y PROPAGACIN DE EXCEPCIONES.............21
5.3.4CMO TRABAJAR CON EXCEPCIONES..........................................22
5.4 PROGRAMACIN DE EXCEPCIONES EN JAVA. UTILIZACIN DE
EXCEPCIONES DE LA LIBRERA Y DEFINICIN DE EXCEPCIONES
PROPIAS 23
5.4.1PROGRAMACIN DE EXCEPCIONES PROPIAS EN JAVA.................23
5.4.2UN EJEMPLO DESARROLLADO DE TRABAJO CON EXCEPCIONES DE LA
API DE JAVA .................................................................................... 26
3.10 EXCEPCIONES EN JAVA

Introduccin:
Las excepciones son el medio que ofrecen algunos lenguajes de programacin
para tratar situaciones anmalas que pueden suceder cuando ejecutamos un
programa. Algunos casos de situaciones anmalas que se pueden citar, son,
por ejemplo, invocar a un mtodo sobre un objeto null, intentar dividir un
nmero por 0, intentar abrir un fichero que no existe para leerlo, quedarnos
sin memoria en la JVM al ejecutar (por ejemplo, debido a un bucle infinito),
intentar crear un fichero en una carpeta en la que no hay permisos de escritura,
tratar de recuperar informacin de Internet cuando no se dispone de conexin,
o simplemente sufrir un apagn elctrico al ejecutar nuestro cdigo.
Como se puede observar en los ejemplos anteriores, las excepciones no son
inherentes a los lenguajes de POO, pero s que lo son a Java como lenguaje de
programacin (tambin se pueden encontrar excepciones en otros lenguajes
como Ada, ML, Eiffel, Prolog, Ruby o el propio C++). Hay que tener en cuenta
que muchos de los mtodos de la propia librera de Java hacen uso de
excepciones, e incluso los programas que hemos desarrollado hasta ahora nos
han permitido observar algunas de ellas (como, por ejemplo, la muy comn
NullPointerException). Por este motivo, cualquier programador en Java tiene
que ser capaz de crear, lanzar y gestionar excepciones de una forma
adecuada.
DEFINICIN DE EXCEPCIONES EN PROGRAMACIN

Definicin: una excepcin es una situacin anmala que puede tener lugar
cuando ejecutamos un determinado programa. La forma en que el programador
trate la misma es lo que se conoce generalmente como manejo o gestin de la

excepcin.
Las excepciones son una forma de intentar conseguir que, si un cdigo fuente
no se ejecuta de la forma prevista inicialmente, el programador sea capaz de
controlar esa situacin y decir cmo ha de responder el programa.
Conviene destacar un malentendido muy comn sobre las excepciones. Las
excepciones no sirven para corregir errores de programacin. Por ejemplo, si
un programa, durante su ejecucin, no encuentra un determinado archivo, por
medio de las excepciones no vamos a conseguir que el archivo aparezca. O
si en un determinado programa intentamos acceder a una posicin de un
array mayor que la longitud del mismo (o a una posicin negativa), las
excepciones no van a conseguir que dicha posicin del array exista. Las
excepciones servirn para (1) alertarnos de dicha situacin y (2) dejarnos
decidir el comportamiento de nuestro programa en dicho caso. Tambin
resultan de gran utilidad en la depuracin de grandes proyectos, ya que
permiten recuperar la traza de los errores fcilmente, evitando que tengamos
que bucear en el cdigo buscando potenciales errores.
En realidad, los resultados que podemos conseguir por medio del uso de
excepciones tambin se pueden conseguir por medio de una detallada atencin
a los fallos que pueden surgir durante la ejecucin de un programa. Trataremos
de verlo con el siguiente ejemplo, en el que en primer lugar gestionaremos los
potenciales errores por medio de mtodos tradicionales y ya conocidos, para
dejar luego paso al uso de excepciones:
Supongamos que queremos escribir un mtodo auxiliar que devuelva la divisin
real de dos nmeros reales (en Java), y que para lo mismo hacemos uso del
operador de la librera /. Un primer cdigo para dicho mtodo podra ser:
public static double division_real (double dividendo, double divisor)
{ return (dividendo / divisor);
}
El cdigo es correcto, y el resultado devuelto por el mtodo se corresponde con
la divisin real de dos nmeros reales. Por ejemplo, lo podemos comprobar con
un sencillo ejemplo:
public static void main (String [] args){
double x = 15.0;
double y = 3.0;
System.out.println ("El resultado de la division real de "
+ x + " entre " + y + " es " + division_real (x, y));
}
El resultado de compilar y ejecutar el anterior programa sera:
El resultado de la division real de 15.0 entre 3.0 es 5.0
El mtodo division_real(double, double): double est correctamente

programado y produce la divisin real de los dos argumentos que recibe.
Sin embargo, hay, al menos, una situacin excepcional que no hemos tenido
en cuenta al programar el mismo. Qu sucedera si al realizar la divisin de
ambos nmeros el denominador de la misma fuese igual a cero?
Lo comprobamos con el siguiente fragmento de cdigo:
double x = 15.0;
double y = 0.0;
System.out.println ("El resultado de la division real de "
+ x + " entre " + y + " es " + division_real (x, y));
}
Al ejecutar la anterior operacin se obtiene como resultado:
El resultado de la division real de 15.0 entre 0.0 es Infinity
Vemos que Java ha sido capaz de proporcionarnos una respuesta, en este
caso Infinity, que se corresponde con el valor que Java asigna a las divisiones
por
cero
(puedes
comprobar
en
http://java.sun.com/javase/6/docs/api/java/lang/Double.html la existencia de
constantes en Java representando los valores de ms y menos infinito, entre
otras).
Puede haber situaciones en las que dicho comportamiento no sea el deseado
por nosotros, ya que un valor Infinity en nuestro programa podra provocar
ms adelante respuestas inesperadas, as que puede que un usuario quiera
tratar dicho caso excepcional de una forma diferente. La forma natural para
ello es definir una estructura condicional (un bloque if ... else ...) que nos
permita separar dicho caso de los casos que el programa puede tratar de forma
convencional. La estructura sera la siguiente:
{ double aux;
if (divisor != 0){
aux = dividendo/divisor;
}
else { aux = ?;
}
return aux;
}
Como siempre que plantemos la anterior situacin, la pregunta que debemos
responder ahora es, qu comportamiento esperaremos de nuestro mtodo en
caso de que el divisor sea igual a cero? Qu valor de aux debera devolver
el mtodo?
Lo primero que debemos tener claro es que el mtodo debe devolver un valor
double, con lo cual no podemos devolver, por ejemplo, un mensaje de error
advirtiendo al usuario de que est intentando dividir por cero. Una alternativa es
devolver lo que se suele denominar como un valor sealado, que nos permita
distinguir que en el mtodo ha sucedido algo anmalo. Un candidato a ser
devuelto sera el propio cero, pero cero tambin es el resultado de dividir 0.0
entre 3.0, por lo que los clientes del mtodo division_real (double, double):
double difcilmente podran distinguir entre una situacin y la otra. Con
cualquier otro valor real encontraramos el mismo problema. Optaremos por
devolver 0.0 en caso de que el divisor sea igual a cero:
{ double aux;
if (divisor != 0){
}
else { aux = 0.0;
}
return aux;
}
Ahora el resultado de ejecutar el anterior fragmento de cdigo sera:
La forma anterior de tratar el caso excepcional, aunque pueda parecer un poco
deficiente, es ampliamente utilizada por mltiples lenguajes de programacin.
Por ejemplo, en las libreras de C y C++ podemos encontrar las siguientes
especificaciones de funciones encargadas de abrir o cerrar ficheros. En
particular, nos vamos a preocupar de la funcin fclose (FILE *): int, que es
propia de la librera cstdio. La especificacin de la funcin ha sido extrada de
http://www.cplusplus.com/reference/clibrary/cstdio/fclose.html:
int fclose ( FILE * stream );
Return Value:
If the stream is successfully closed, a zero value is returned.
On failure, EOF is returned.
La funcin fclose (FILE *): int tiene por cometido cerrar el fichero que se le
pasa como parmetro. Como se puede observar, el valor de retorno de la
misma es un entero. Al leer detenidamente la especificacin de su Return
Value podemos observar que la misma devolver cero en caso de que el

fichero haya sido correctamente cerrado, o el valor EOF, que es un entero
negativo, en caso de que haya sucedido algn error al cerrar el mismo. Es
decir, si sucede algo anmalo que no nos permita completar la accin, la
funcin nos avisar por medio del valor EOF (en lugar de, por ejemplo,
mandarnos un mensaje o una seal advirtiendo de tal situacin).
Si el programador que hace uso de la funcin fclose (FILE *): int tiene en
cuenta que dicha funcin puede devolver un valor negativo, es probable que
sea capaz de reaccionar ante tal hecho, y proponer un comportamiento
especfico para este caso alternativo. En caso contrario, el flujo del programa
seguir siendo el mismo, si bien el fichero no estar cerrado, tal y como
nosotros esperbamos.
Aqu es donde las excepciones suponen una diferencia sustancial con respecto
a la forma de gestionar los errores por medio de valores sealados (como un
valor negativo, en el caso de la funcin fclose (FILE *): int, o devolver 0.0 en
el caso de una divisin entre 0.0 con la funcin division_real(double, double):
double).
Las excepciones tienen dos caractersticas principales a las cuales debemos
prestar atencin:
1) En primer lugar, las excepciones nos van a permitir enriquecer los mtodos, en
el sentido de que un mtodo no slo va a poder devolver un valor de un
determinado tipo (por ejemplo, un double o un int en las funciones
anteriores), sino que nos van a permitir que un mtodo lance una excepcin.
2) En segundo lugar, nos van a permitir alterar el flujo natural de un programa y
que ste no sea nico. Siguiendo con la propiedad que hemos citado en 1), si
un mtodo va a poder devolver un valor de un tipo determinado o lanzar una
excepcin, el programa cliente de dicho mtodo debe estar preparado para
ambos comportamientos, y eso hace que la ejecucin de un programa no vaya
a ser lineal, tal y como la entendamos hasta ahora, sino que puede variar
dependiendo de los valores o excepciones que produzca cada llamada a un
mtodo.
Veamos en primer lugar la caracterstica que mencionamos en 1). Vamos a
hacer que nuestro mtodo division_real(double, double): double sea capaz de
enviar una seal de que se ha producido una situacin anmala a sus clientes
(en este caso, slo el mtodo main) cuando el divisor sea igual a 0.0. El
cdigo del mtodo auxiliar division_real(double, double): double pasa ahora a
ser:
public static double division_real (double dividendo, double divisor) throws
Exception{ double aux;
if (divisor != 0){
}
else {
throw new Exception();

return aux;
}
Veamos los cambios que han tenido lugar en el mtodo con respecto a su
versin anterior:
1) En primer lugar, la cabecera del mismo ha sufrido una modificacin, pasando
ahora a ser:
public static double division_real (double dividendo, double divisor) throws Exception{}
Dicha cabecera expresa el siguiente comportamiento:
El mtodo division_real (que es pblico, esttico, y tiene como parmetros
dos valores de tipo double) puede, o bien devolver un valor double, o bien
lanzar un objeto de la clase Exception.
Vemos aqu una primera gran diferencia derivada de trabajar con excepciones.
El flujo del cdigo puede adoptar distintas direcciones. O bien el mtodo
division_real (double, double): double puede devolver un nmero real, o bien
puede lanzar una excepcin, en la forma de un objeto de la clase Exception.
Los clientes de dicho mtodo deben ser capaces de soportar ambos
comportamientos, lo cual veremos un poco ms adelante.
2) La segunda diferencia sustancial del mtodo division_real(double, double):
double con respecto a su versin anterior la encontramos, precisamente, al
estudiar el caso excepcional:
double aux;
if (divisor != 0){
}
else { throw new Exception();
}
return aux;
Como se puede observar en la parte correspondiente al else {} (es decir,
cuando el divisor es igual a 0), lo que se hace no es darle un valor sealado
(o arbitrario) a la variable aux, sino que lo que hacemos es, primero construir
un objeto de la clase Exception (propia de Java, y de la que luego daremos
detalles), y posteriormente lanzarlo por medio del comando throw (insistimos
una vez ms, lo que hacemos es lanzar la excepcin a nuestro cliente, en
este caso el mtodo main).
Al lanzar dicha excepcin, el flujo de nuestra aplicacin vuelve al cliente de la

funcin division_real(double, double): double, y ya no se llega a ejecutar la
orden return aux;.
Nota: cabe sealar que sta no es la nica forma de gestionar las excepciones,
ms adelante veremos algunas formas distintas.
Despus de ver los cambios que hemos debido introducir en el mtodo

division_real (double, double): double para poder decidir el caso excepcional y
crear y lanzar la excepcin, pasamos ahora a ver los cambios que debemos
realizar en los clientes de dicho mtodo para que sean capaces de capturar la
excepcin que lanza el mismo.
El comportamiento de los clientes del mtodo division_real (double, double):
double debe estar preparado para este nuevo escenario, en el que puede
recibir un double, pero tambin puede que le llegue un objeto de la clase
Exception. De nuevo, hay varias formas de prepararse para gestionar la
excepcin. Nos quedamos en este ejemplo con una de ellas que consiste en
capturar la excepcin y gestionarla. Eso se podra hacer por medio de los
siguientes cambios en nuestro cdigo para el mtodo main:
double x = 15.0;
double y = 3.0;
try{
System.out.println ("El resultado de la division real de " + x +
" entre " + y + " es " + division_real (x, y));
}
catch (Exception mi_excepcion){
System.out.println ("Has intentado dividir por 0.0;");
System.out.println ("El objeto excepcion lanzado: " +
mi_excepcion.toString());
}
}
Veamos los cambios principales que hemos tenido que realizar en nuestro
cdigo:
1) En primer lugar, con respecto a la versin anterior, podemos observar cmo la
llamada al mtodo que lanza la excepcin, division_real (double, double):
double est ahora encerrada en un bloque try {...} de la siguiente forma:
try{

El bloque try {...} puede ser entendido como una forma de decirle a nuestro
cdigo intenta ejecutar las rdenes dentro de este bloque, de las cuales
alguna podra lanzar una excepcin (en nuestro caso, division_real(double,

double): double).
2) La segunda modificacin que debe ser incluida en nuestro cdigo es el bloque
catch (...) {...}. Lo primero que debemos notar es que un bloque try
{...} siempre debe ir acompaado de un (o varios) bloque catch (...) {...}. La
funcin del bloque catch (...) {...} es precisamente la de capturar (o coger)

las excepciones que hayan podido surgir en el bloque previo try{...}. En
nuestro caso, el mismo tena el siguiente aspecto:
System.out.println ("El objeto excepcion lanzado: " +
mi_excepcion.toString());
}
Veamos detalladamente la sintaxis del mismo:
a)
En primer lugar, la orden catch es la que comienza el bloque.
b) Seguido de ella podemos encontrar la indicacin catch (Exception

mi_excepcion) {...}. La parte situada entre parntesis indica el tipo de
excepcin que vamos a capturar en este bloque. La misma debera coincidir
con alguna de las que se han lanzado en el bloque try {..}, es decir, en
nuestro caso Exception. Adems de eso, le damos un identificador local a la
misma (en nuestro caso, mi_excepcion) que ser vlido dentro del bloque que
va a continuacin. Por tanto, el bloque catch (Exception mi_excepcion) {...}
captura una excepcin de la clase Exception y la etiqueta con el nombre
mi_excepcion. En la parte correspondiente al bloque {...} introduciremos los
comandos que queremos realizar en caso de que haya tenido lugar la
excepcin de tipo Exception. En nuestro caso, la nica orden que hemos
incluido en dicho bloque sera:
System.out.println ("El objeto excepcion lanzado: " + mi_excepcion.toString());
Lo cual quiere decir que si la excepcin de tipo Exception tiene lugar, se
mostrarn por pantalla los mensajes sealados.
La accin a realizar depende del contexto en el que nos encontremos. Si, por
ejemplo, la excepcin detectada fuese un error de escritura a un fichero,
podramos optar por escribir a un fichero distinto. Si fuese un error del formato
de los datos de entrada, podramos pensar en pedirlos de nuevo al usuario, o
en finalizar la ejecucin del programa advirtiendo de dicho extremo.
En cualquier caso, debe quedar claro que si pretendemos gestionar una
excepcin lanzada por un mtodo al que invoquemos, debemos facilitar un
bloque try {...} en el que se incluya la llamada a dicho mtodo, y un mtodo
catch (TipoExcepcion nombre_excepcion) {...} que indique, precisamente, lo
que se debe hacer cuando surja tal excepcin.
Veamos ahora el resultado de ejecutar el anterior cdigo.
Si lo ejecutamos con una entrada no excepcional, por ejemplo, con

valores 15.0 y 3.0 que utilizamos inicialmente:
los

double x = 15.0;
double y = 3.0;
try{
}
System.out.println ("El objeto excepcion lanzado: "
+ mi_excepcion.toString());
}
}
Al encontrarnos fuera del caso excepcional, la ejecucin es la esperada, y el
resultado de compilar y ejecutar el programa sera:
Si, por el contrario, la entrada que le damos al programa se encuentra dentro
del caso excepcional, es decir, el divisor es igual a cero:
double x = 15.0;
double y = 0.0;
try{
System.out.println ("El resultado de la division entera de " + x +
}
System.out.println ("El objeto excepcion lanzado: "
+ mi_excepcion.toString());
}
}
El resultado sera el siguiente:
Has intentado dividir por 0.0;
El objeto excepcion lanzado: java.lang.Exception
Podemos observar que el caso excepcional ha tenido lugar, y por tanto el
mtodo division_real (double, double): double ni siquiera ha llegado a ejecutar
su orden return aux, sino que se ha salido de l por medio de la orden throw
new Exception();, y eso ha provocado que en el programa cliente main el
flujo de ejecucin se haya introducido en la clusula catch (Exception

mi_excepcion) {...}, alterando el flujo normal de ejecucin del programa.
Lo anterior nos ha servido para mostrar las caractersticas principales de las
excepciones. Es importante retener la idea de que las excepciones en Java nos
permiten enriquecer el comportamiento de los mtodos, ya que por el uso de

excepciones podemos conseguir que los mtodos devuelvan un valor
determinado de un tipo cualquiera o que tambin lancen una excepcin.
Tambin es importante tener en cuenta que el programador, cuando define un
mtodo, decide cules van a ser los casos anmalos o excepcionales que va
a considerar su mtodo. Como consecuencia de esto, cuando utilicemos
mtodos de la API de Java, deberemos comprobar siempre cules son las
excepciones que los mismos pueden lanzar, para as gestionarlas de forma
conveniente.
TIPOS DE EXCEPCIONES / ERRORES Y CMO TRATARLOS
Lo primero que debe quedar claro es que en Java, todas las excepciones que
podamos usar o crear propias, deben heredar de la clase Exception propia de
la
librera
de
Java.
Existe una superclase de Exception, llamada Throwable que sirve para
representar la clase de la que deben heredar todas las clases que queramos
lanzar, por medio del comando throw. Slo existen dos subclases directas
de Throwable en la API de Java. Una es la clase Error que se utiliza para
representar algunos errores poco comunes que pueden tener lugar cuando
ejecutamos una aplicacin en Java (por ejemplo, que la JVM se quede sin
recursos). Java da la opcin de que el usuario los gestione, pero en general no
es recomendable hacerlo. La otra subclase directa de Throwable es
Exception, y esta clase sirve para representar, citando a la propia API de
Java, condiciones que una aplicacin razonable quiz quiera capturar.
Sera conveniente comprobar algunos de los mtodos y caractersticas de la
clase Exception para poder trabajar con ella de un modo adecuado. En primer
lugar, con respecto a su lista de mtodos, podemos observar que cuenta con
diversos constructores:
1) Exception(): un primer constructor sin parmetros, que es del cual hemos
hecho uso en nuestro ejemplo anterior.
2) Exception (String message): un segundo constructor, con un parmetro de
tipo String, que nos permite crear la excepcin con un determinado mensaje.
Este mensaje puede ser accedido por medio del mtodo getMessage(): String
que mostraremos posteriormente.
Existen otros dos constructores para la clase Exception, pero por lo general
no haremos uso de ellos.
Por lo dems, la clase no cuenta con mtodos propios, pero s con algunos
mtodos heredados de sus superclases que nos sern de utilidad.
Especialmente tiles nos resultarn:
1) toString(): String que como ya conocemos pertenece a la clase Object. De

todos modos, su comportamiento es redefinido (tal y como tambin hacamos
nosotros en el Tema 3) en la clase Throwable para que su comportamiento
sea el siguiente:
Si hemos creado la excepcin con un message, el resultado de invocar al
mtodo toString(): String ser la siguiente cadena de texto:
NombreDeLaClase: message
En caso contrario, como ya comprobamos en nuestro ejemplo anterior de
excepciones, el resultado ser la siguiente cadena de texto:
NombreDeLaClase
2) getClass(): Class, mtodo que est heredado tambin de la clase Object, y
que lo que hace es devolver la clase del objeto sobre el que se invoca. Para
nosotros, con conocer el nombre de dicha clase ser suficiente.
3) getMessage(): String, es un mtodo que pertenece a la clase Throwable y
que nos devuelve una String que contiene el mensaje original con el que fue
creado el objeto.
4)printStackTrace():void es un mtodo que pertenece a la clase Throwable y
que directamente imprime a la salida estndar de errores (en nuestro caso, la
consola MSDOS) el objeto Throwable desde el que se invoca, as como la
traza de llamadas a mtodos desde el que se ha producido la excepcin.
Resulta de utilidad sobre todo para depurar programas, ya que nos ayuda a
saber el punto exacto de nuestro cdigo en el que surge la excepcin, y el
mtodo que la ha producido.
Por supuesto, el comportamiento de todos estos mtodos puede ser variado
(redefinido) por nosotros al declarar nuestras propias clases que hereden de
Exception.
Si seguimos observando la especificacin que de la clase Exception se da en
la API de Java y prestamos atencin a la seccin Direct Known Subclasses,
podemos observar ya algunas de las clases que en Java se van a considerar
como excepciones de programacin. No vamos a enumerar todas ellas, slo
algunas de las ms destacadas o que ya hemos visto en nuestro trabajo con
Java:
-ClassNotFoundException
Esta excepcin tiene lugar cuando intentamos ejecutar un proyecto y, por
ejemplo, la clase que contiene la funcin main no ha sido aadida al mismo o
no es encontrada (una causa muy comn para lo mismo es el haber
configurado mal el proyecto).
-RuntimeException
la clase RuntimeException representa el conjunto de las excepciones que
pueden tener lugar durante el proceso de ejecucin de un programa sobre la
JVM, con la peculiaridad de que el usuario no tiene que prestar atencin al
hecho de capturarlas (todas
las
dems
excepciones
debernser capturadas
o gestionadas en algn modo
por el usuario).
Dentro
de
la
especificacin
de
la
clase
RunTimeException
podemos encontrar un numeroso grupo de excepciones, con algunas de las
cuales ya estamos familiarizados, y que conviene citar:
-ClassCastException
excepcin que tiene lugar cuando intentamos hacer un cast de un objeto a
una clase de la que no es subclase. Un ejemplo sencillo est en la propia API
de Java:
Object x = new Integer(0);
System.out.println((String)x);
Al no ser la clase Integer una subclase de String, no podemos hacer un
cast de forma directa. La situacin anterior producira una
ClassCastException en tiempo de ejecucin, no antes, que no es necesario
que el usuario gestione.
-IndexOutOfBoundsException
excepcin que tiene lugar cuando intentamos acceder a un ndice de un
array, String o vector mayor que el nmero de elementos de dicha
estructura. Veamos tambin un ejemplo sencillo:
int array_enteros [] = new int [50];
System.out.println (array_enteros [67]);
Al intentar acceder a una posicin del array mayor que la dimensin del
mismo, podemos observar como Java lanza una excepcin para advertirnos de
que dicha direccin de memoria no ha sido reservada. De nuevo, estamos ante
una excepcin que aparecer en tiempo de ejecucin, y que no es necesario
que el usuario gestione. Qu habra sucedido en C++ ante esta misma
situacin?
-NegativeArraySizeException
excepcin que tiene lugar cuando intentamos crear un array con longitud
negativa. Un ejemplo de una situacin donde aparecera tal excepcin sera el
siguiente:
int array_enteros [] = new int [-50];
De nuevo es una excepcin que el usuario no debe gestionar (pero debe ser
consciente de que puede surgir en sus programas). Repetimos la pregunta que
lanzbamos con la excepcin anterior, qu habra pasado en C++ ante esa
situacin?
-InputMismatchException
excepcin que lanzan varios mtodos de la librera Scanner de Java cuando
estn recorriendo una entrada en busca de un dato y ste no existe en la
entrada. Por ejemplo, si tenemos la siguiente entrada abierta:
Hola
Esto es un scanner
Que slo contiene texto
Y sobre el mismo tratamos de ejecutar el mtodo nextDouble(): double,
obtendremos dicha excepcin. Una vez ms, no es obligatorio gestionarla,
aunque dependiendo de nuestra aplicacin puede ser importante hacerlo.
-NumberFormatException
esta excepcin tiene lugar cuando intentamos convertir un dato de tipo
String a algn tipo de dato numrico, pero el dato de tipo String no tiene el
formato adecuado.
Es usada, por ejemplo, en los mtodos parseDouble(): double, parseInt():
int, parseFloat(): float, ... .
-NullPointerException
quiz sta sea la excepcin que ms comnmente aparece cuando se trabaja
con Java. Surge siempre que intentamos acceder a cualquier atributo o mtodo
de un objeto al que le hemos asignado valor null. Un caso sencillo donde
aparecera sera el siguiente:
Object ds = null;
ds.toString();
Como se puede observar, el objeto ds ha sido inicializado (con el valor null),
lo que nos previene de obtener un error de compilacin en Java, y al intentar
acceder a cualquiera de sus mtodos (por ejemplo, el mtodo toString():
String), al invocar a un mtodo sobre la referencia nula, obtenemos la
excepcin NullPointerException. Similar excepcin se obtiene tambin en la
siguiente situacin:
Object array_ob [] = new Object [25];
array_ob[1].toString();
Declaramos y creamos un array de objetos de la clase Object, pero no

inicializamos cada uno de dichos objetos; esto quiere decir que cada
componente del array contiene el objeto null. Al intentar acceder a cualquier
propiedad (por ejemplo, toString(): String) de cualquiera de ellos, obtenemos
una excepcin de tipo NullPointerException.
Esta excepcin tampoco es necesario gestionarla, pero s que conviene
conocer su origen ya que puede ser de gran utilidad a la hora de depurar y
corregir programas.
Veamos ahora algunas nuevas excepciones, que heredan de la clase
Exception en Java, pero no de RunTimeException, y que por tanto los
usuarios deben gestionar, al hacer uso de los mtodos que las lancen:
-IOException (http://java.sun.com/javase/6/docs/api/java/io/IOException.html ):
sta es otra de las excepciones ms comnmente usadas en la librera de
Java. Los mtodos de Java la lanzan siempre que encuentren un problema en
cualquier operacin de lectura o escritura a un medio externo (lectura o
escritura a un fichero, por ejemplo).
Puedes observar la lista de mtodos de la API de Java que la pueden lanzar en
http://java.sun.com/javase/6/docs/api/java/io/class-use/IOException.html ,
as
que cada vez que hagas uso de alguno de esos mtodos debers gestionarla
de algn modo.
Tambin deberas observar todas sus subclases (es decir, las excepciones que
heredan de ella), porque algunas son tambin muy comunes
(http://java.sun.com/javase/6/docs/api/java/io/IOException.html). Gracias a los
mecanismos de herencia aplicados a excepciones, siempre que gestiones una
IOException estars capturando tambin cualquiera de las excepciones que
heredan de la misma.
Tambin puedes observar en la pgina anterior que la lista de constructores y
mtodos de la misma es equivalente al de la clase Exception.
-FileNotFoundException
esta excepcin hereda de la clase IOException que acabamos de introducir.
En general, la lanzan diversos mtodos de la API de Java cuando intentan abrir
algn fichero que no existe o no ha sido encontrado.
Aparte de estas excepciones, cada usuario puede definir las suyas propias, tal
y como veremos en la Seccin 5.4, simplemente declarando una clase que
herede de la clases Exception o RunTimeException (si preferimos que sea
una excepcin que pueda no ser gestionada) de Java.
TRABAJANDO CON EXCEPCIONES: DECLARACIN, CONSTRUCCIN,

LANZAMIENTO Y GESTIN DE EXCEPCIONES
Una vez conocemos algunas de las excepciones ms comunes con las que nos
podemos encontrar al programar en Java, en esta Seccin pasaremos a ver
cmo debemos trabajar con las mismas, es decir, cmo debemos gestionarlas.
En general, cuando dentro de un mtodo aparece una excepcin es porque el
propio mtodo la ha creado y lanzado, o porque dicha excepcin ha venido
lanzada de algn otro mtodo que ha sido invocado desde ste.
A partir de esa situacin, y como norma general se puede enunciar que, un
mtodo cualquiera, cuando se encuentra con una excepcin (por cualquiera de
los dos motivos anteriores) que no sea de tipo RunTimeException, puede
propagar la misma, o puede capturarla y gestionarla (si es de tipo
RunTimeException, el hecho de gestionarla es opcional, depende del
programador).
En la Seccin 5.1 ya hemos visto un sencillo ejemplo en el cual hemos lanzado
y capturado una excepcin, que es una de las formas habituales de
gestionarlas, pero no la nica. En esta Seccin veremos tres formas distintas
de gestionar una excepcin que se podran declarar como propagar la misma
(Seccin 5.3.1), capturar y gestionar la misma (Seccin 5.3.2), y, por ltimo,
una combinacin de los dos mtodos anteriores, capturar, gestionar y
propagar la excepcin.
Para ello vamos a escoger un ejemplo sencillo. Imagina que tenemos un
mtodo auxiliar que recibe como parmetro un array de nmeros reales y un
entero. Dicho mtodo devolver la posicin del array indicada por el entero.
Como ya hemos indicado antes, Java cuenta con excepciones propias
(IndexOutOfBoundsException) que se encargan de esta misin, pero dicha
excepcin es de tipo RunTimeException, por lo cual no es obligatorio que sea
gestionada por el usuario. Lo que haremos ser gestionar el caso excepcional
anterior (que no exista el ndice que se nos solicita) por medio de una
excepcin de la clase Exception, que s debe ser gestionada por el usuario.
PROPAGACIN DE EXCEPCIONES
Veamos en primer lugar qu aspecto podra tener el mtodo auxiliar que nos
solicita el problema:
public static double acceso_por_indice (double [] v, int indice){
return v [indice];
}
Un sencillo programa cliente que hace uso del mtodo auxiliar podra ser el
siguiente:

double array_doubles [] = new double [500];
for (int i = 0; i < 500; i++){
array_doubles [i] = 7 * i;
}
for (int i = 0; i < 500; i = i + 25){
System.out.println ("El elemento en " + i + " es "
+ acceso_por_indice (array_doubles, i));
}
}
Presentaremos en primer lugar la forma de hacer que el mtodo auxiliar
acceso_por_indice (double [], int): double sea capaz de lanzar una excepcin
cuando no se cumple la condicin que hemos exigido.
public static double acceso_por_indice (double [] v, int indice) throws Exception{
if ((0<=indice) && (indice <v.length)){
return v [indice];
}
else { //Caso excepcional:
throw new Exception (El indice + indice +
no es una posicion valida);
}
}
Veamos los cambios que hemos introducido en el mtodo al declarar y

propagar la excepcin:
1. En primer lugar, hemos declarado una estructura condicional, por medio de un
if ... else ... que nos permite separar los casos buenos de los casos
excepcionales. En el mismo puedes observar que hemos hecho uso de
length, que es un atributo de instancia con el que cuentan todos los arrays y
que nos permite saber cuntas componentes han sido reservadas para el
mismo.
Si se verifica la condicin bajo el if, el mtodo auxiliar se comportar como
debe y su resultado ser el esperado.
2. En caso de que el valor de indice se encuentre fuera del rango especificado,
es cuando nos encontramos con el caso excepcional. Como se puede
observar, lo que hacemos es crear un objeto por medio del constructor
Exception (String), y lanzarlo por medio del comando throw.
3. Lo tercero que debemos observar es que el objeto que hemos lanzado por
medio de throw no ha sido capturado dentro del mtodo acceso_por_indice
(double [], int): double, lo cual quiere decir que esa excepcin est siendo
propagada por el mtodo. Todos los mtodos clientes de este mtodo debern
tenerlo en cuenta a la hora de ser programados, gestionando la excepcin que
les podra llegar. Cabe recordar que las dos opciones que existen ante una
excepcin que ha sido lanzada son capturar la misma y gestionarla, o en su
defecto propagarla (al mtodo que haya invocado este mtodo). En este caso,
nos hemos decantado porque nuestro mtodo acceso_por_indice (double [],
int): double propague la excepcin, y para ello debemos indicar en la cabecera

del mtodo dicha situacin.
De ese modo la cabecera queda como:
public static double acceso_por_indice (double [] v, int indice) throws Exception{}
Por medio del comando throws Exception estamos avisando de que nuestro
mtodo lanza una excepcin, y por tanto cualquier usuario que invoque al
mismo deber capturar dicha excepcin, o, si lo prefiere, de nuevo propagarla.
Veamos ahora por ejemplo cmo queda la llamada al mismo que hacamos
desde el cliente main de nuestro mtodo acceso_por_indice (double [], int):
for (int i = 0; i < 500; i++){
}
for (int i = 0; i < 600; i = i + 25){
try {
}
catch (Exception e)
{ System.out.println
(e.toString());
}
}
}
Como se puede observar, el hecho de que acceso_por_indice (double [], int):
double lance una excepcin ha hecho que, al hacer uso del mismo, tengamos
que capturarla y gestionarla dentro de nuestro mtodo main, por medio de
una estructura try {...} catch (...) {...}.
De nuevo, nuestro mtodo main podra haber propagado la excepcin, por
medio de la cabecera:
public static void main (String [] args) throws Exception{..}
Aunque esta solucin no resulta muy elegante, ya que nos hace perder la
informacin de dnde y cmo se han producido las excepciones.
Por ltimo, podemos prestar atencin a la salida que produce la ejecucin del
fragmento de cdigo anterior. En este caso sera:
El elemento en 0 es 0.0
java.lang.Exception: El indice 500 no es una posicion
valida java.lang.Exception: El indice 525 no es una
posicion valida java.lang.Exception: El indice 550 no es
una posicion valida java.lang.Exception: El indice 575 no
es una posicion valida
Como se puede observar, todas y cada una de las veces que hemos llamado al
mtodo acceso_por_indice (double [], int): double con un valor fuera del rango
del array la respuesta que hemos obtenido es la excepcin correspondiente
que nos avisa de que se ha producido dicha situacin excepcional (y el mtodo
acceso_por_indice (double[], int): double no ha tenido que devolver un valor
double, sino que simplemente ha lanzado la excepcin mostrada).
CAPTURA Y GESTIN DE EXCEPCIONES

La segunda opcin que hay ante una excepcin es capturar la misma y
gestionarla (como ya hemos visto en algunos ejemplos anteriores). Lo que
haremos ahora ser programar el mtodo acceso_por_indice (double [], int):
double de tal forma que l mismo lance y capture su propia excepcin. Una
posible solucin para lo mismo sera:
public static double acceso_por_indice (double [] v, int indice){
try {
return v [indice];
}
else {
//Caso excepcional
throw new Exception ("El indice " + indice +
" no es una posicion valida");
}
}
System.out.println(mi_excepcion.toString());
System.out.println(mi_excepcion.getMessage());
}
finally {
return 0.0;
}
}
Veamos algunas peculiaridades sobre la sintaxis de la captura y gestin de la
excepcin:
1. En primer lugar, la estructura try {...} catch(...){...} con la que ya nos hemos
encontrado con anterioridad.
Dentro de la parte try{...} es donde debe surgir la excepcin, en este caso,
donde debe estar el throw. En este caso, la excepcin que puede surgir de
este fragmento de cdigo es de tipo Exception, y se debe ser el tipo de
excepciones que capturemos dentro de la estructura catch(...){...}.
En la estructura catch (...){...} hay dos partes diferenciadas que debemos
destacar:
- En primer lugar, entre parntesis, como si fuera la cabecera de un mtodo,
debemos situar el tipo de excepcin que queremos capturar (en nuestro caso,
Exception), seguido de un identificador para el mismo, por ejemplo
mi_excepcion, que ser el identificador por el que nos podamos referir a la
misma en el bloque entre llaves:
catch (Exception mi_excepcion){...}
- En segundo lugar, entre llaves, nos podemos encontrar con la parte en la que
gestionamos la excepcin. Qu queremos hacer en caso de que surja la
excepcin? Por ejemplo, en nuestro caso, lo que vamos a hacer es
simplemente mostrar un mensaje por pantalla que nos permita saber de qu
tipo es la excepcin generada, y mostrar el mensaje que le hemos asignado a
la misma:
System.out.println(mi_excepcion.toString());
}
2. En segundo lugar, podemos observar el bloque finally {...} tambin propio del
trabajo con excepciones (debe ir siempre a continuacin de un bloque try
{...} catch (...) {...}), que nos permite realizar ciertas acciones que nos permitan
salir del mtodo acceso_por_indice (double [], int): double de una forma ms
correcta o elegante. Por ejemplo, dicho bloque se podra utilizar para cerrar
la conexin con un fichero que tuviramos abierto, o con una base de datos, o
para vaciar los bferes, ... .
En nuestro caso, y ya que nuestro mtodo ha de devolver un double, lo

hemos usado para situar la sentencia return 0.0; como valor por defecto del
mtodo.
3. Por ltimo, cabe tambin destacar que la cabecera del mtodo ya no lanza
ninguna excepcin, sino que la gestiona por s mismo, y por tanto ha vuelto a
ser:
public static double acceso_por_indice (double [] v, int indice){}
Los clientes de este mtodo ahora no debern preocuparse de que el mtodo
acceso_por_indice (double[], int): double lance una excepcin, ya que el
propio mtodo las captura y gestiona. Veamos entonces ahora un posible
cliente main para el mismo:
for (int i = 0; i < 500; i++){
}
for (int i = 0; i < 600; i = i + 25){
}
}
Como podemos observar, el mismo no presta atencin a la captura y gestin
de excepciones. El resultado de ejecutar ahora el mismo ser:

java.lang.Exception: El indice 500 no es una posicion valida
El indice 500 no es una posicion valida

En la salida anterior del programa se puede observar como cada vez que ha
ocurrido una excepcin la misma ha sido gestionada por el propio mtodo
acceso_por_indice (double [], int): double. Esto tiene una contrapartida, y es
que el mtodo acceso_por_indice (double [], int): double debe devolver
siempre un double (no existe la posibilidad de que el mtodo lance una
excepcin), y por tanto debemos devolver un valor comodn, que en nuestro
caso ser 0.0.
El hecho de gestionar la excepcin en el propio mtodo ha hecho que los
clientes del mismo no sean conscientes de que tal excepcin ha sucedido y por
tanto no pueden actuar en consecuencia. En cierto modo, el hecho de capturar
la excepcin de forma prematura ha hecho que se pierda parte de la utilidad de
la misma, que es avisar a los clientes de nuestro mtodo de que una situacin
excepcional se ha producido en el mismo. Este tipo de gestin de excepciones
puede resultar ms til para depurar nuestro propio cdigo, detectar errores en
el mismo, ...
Veamos por ltimo la posibilidad de capturar y gestionar la excepcin y adems
propagarla, que no deja de ser una combinacin de los dos mtodos anteriores.
CAPTURA, GESTIN Y PROPAGACIN DE EXCEPCIONES

Al programar el mtodo acceso_por_indice (double [], int): double podemos
decidir que el mismo capture la excepcin y adems la propague. La solucin
es una combinacin de las dos que hemos visto hasta ahora. Una posible
programacin del mtodo para que se comporte de dicho modo sera:
public static double acceso_por_indice (double [] v, int indice) throws Exception{
try {
return v [indice];
}
else {
}
}
//Caso excepcional:
throw new Exception ("El indice " + indice
+ " no es una posicion valida");
catch (Exception mi_excepcion)

{ System.out.println(mi_excepcion.toString());
throw mi_excepcion;
}
}
En realidad el mtodo no aade nada que no hayamos visto en los anteriores
casos. En el bloque else {...} se lanza una excepcin en todos aquellos casos
que nos encontremos fuera del rango del array. La misma se captura en el
bloque catch (Exception mi_excepcion){...}.
Como se puede observar, en el mismo, la excepcin se gestiona (por medio de
mostrar por pantalla un mensaje que nos informa de la misma, gracias a los
mtodos toString(): String y getMessage (): String), y, como se puede
observar, la volvemos a lanzar (la propagamos), por medio del comando throw
mi_excepcion;. Esto hace que la excepcin sea lanzada a los clientes de
nuestro mtodo acceso_por_indice (double [], int): double, y que los mismos
deban capturarla y gestionarla.
Por ejemplo, podramos recuperar el main que presentamos en la Seccin
5.3.1, que en este caso tambin funcionara de forma satisfactoria:
for (int i = 0; i < 500; i++)
{ array_doubles [i] = 7 *
i;
}
for (int i = 0; i < 600; i = i + 25){
try {
}
catch (Exception e){
System.out.println (e.toString());
}
}
}
Cada llamada al mtodo acceso_por_indice (double [], int): double est
encerrada en un bloque try {..} catch (...) {...} que nos permite capturar y
gestionar la excepcin que nos puede mandar acceso_por_indice (double [],

int): double.
CMO TRABAJAR CON EXCEPCIONES

Despus de presentar las tres formas anteriores de trabajar con excepciones
ahora correspondera indicar las ventajas y desventajas de cada una de ellas.
En general es difcil dar recetas universales sobre cmo trabajar con

excepciones. An ms, depende de si estamos programando mtodos
auxiliares que deben lanzar dichas excepciones, o aplicaciones que hacen uso
de otros mtodos que lanzan dichas excepciones.
Lo que s podemos hacer es sealar cmo se hace, por lo general, en la librera
(o API) de Java. En la API de Java generalmente los mtodos existentes
siguen la estrategia presentada en la Seccin 5.3.1, es decir, la de generar
excepciones y lanzarlas para que los mtodos que los invoquen las gestionen
como consideren oportuno. En cierto modo, los mtodos de la API de Java
siguen la estrategia de dejar que el usuario de tales mtodos decida qu
quiere hacer ante una situacin excepcional, obligndole a programar bloques
try {...} catch (...) {...} cuando haga uso de mtodos de la librera que lanzan
excepciones, o, en su defecto, a propagarlas indefinidamente (en Java existe
incluso la posibilidad de propagarlas en la cabecera del mtodo main, con lo
cual no deberamos gestionarla; de nuevo, esta prctica no es muy
recomendable, ya que delegamos en lo que el sistema quiera hacer con dicha
excepcin).
Aun as, la propia librera de Java tambin ha definido gran parte de sus
excepciones como RunTimeException, o herederas de dicha clase, de tal
modo que las aplicaciones finales pueden evitar gestionar o capturar dichas
excepciones (aunque pueden hacerlo si as lo consideran necesario).
En la siguiente Seccin veremos cmo programar nuestras propias
excepciones, as como un caso ms general de captura y gestin de
excepciones.
PROGRAMACIN DE EXCEPCIONES EN JAVA. UTILIZACIN DE
EXCEPCIONES DE LA LIBRERA Y DEFINICIN DE EXCEPCIONES
PROPIAS
Esta Seccin estar dividida en dos partes. En la Seccin 5.4.1 explicaremos
cmo programar excepciones propias en Java. En la Seccin 5.4.2 veremos un
ejemplo un poco ms elaborado que los anteriores donde presentaremos un
caso de uso donde pueden aparecer un rango ms amplio de excepciones.
PROGRAMACIN DE EXCEPCIONES PROPIAS EN JAVA

Aparte de todas las excepciones propias que existen en la librera de Java, que
puedes
encontrar
a
partir
de
y explorando todas las subclases de las mismas, y de las cuales hemos
presentado algunas en la Seccin , en Java tambin es posible definir
excepciones propias.
La metodologa para lo mismo es sencilla. Slo debemos declarar una clase

que herede de la clase Exception en Java. De este modo, habremos creado
una clase de objetos que pueden ser lanzados (o sea, que podemos utilizar con
el comando throw) y que por tanto pueden ser utilizados para sealar una
situacin anmala de cualquier tipo.
Generalmente, a la hora de declarar una nueva excepcin, buscaremos un

nombre que resulte descriptivo de la misma. Veamos cmo definir una clase de
excepciones que nos sirva para representar la excepcin que hemos lanzado
en la Seccin 5.3. El nombre que elegimos para la misma podra ser
IndiceFueraDeRangoExcepcion (por cierto, la API de Java cuenta con una
excepcin que se puede usar en situaciones similares, llamada
IndexOutOfBoundsException).
Una decisin relevante que debemos tomar a la hora de definirla es si la misma
debe heredar de la clase Exception o de la clase RunTimeException. Como
ya dijimos al introducir las excepciones en la Seccin 5.2, caso de que la
hagamos heredar de Exception tendremos la obligacin de capturar y
gestionar la misma (o de propagarla), mientras que si la hacemos heredar de
RunTimeException el gestionar la misma pasar a ser opcional.
En este caso, la haremos heredar de Exception. Veamos una posible
definicin para la misma:
class IndiceFueraDeRangoExcepcion extends
Exception{ public IndiceFueraDeRangoExcepcion (){
super();
}
public IndiceFueraDeRangoExcepcion (String s){
super(s);
}
}
Como se puede observar, la definicin de la clase es bastante sencilla. Lo ms
reseable de la cabecera es la declaracin de herencia que hemos realizado
en la cabecera, class IndiceFueraDeRangoExcepcion extends Exception{...}.
Posteriormente, hemos definido dos constructores para la misma, siguiendo el
estilo de la definicin de la clase Exception en Java
Dichos
constructores nicamente invocan al constructor de la clase base. El resto de
mtodos de la clase IndiceFueraDeRangoExcepcion sern los heredados de
la clase Exception.
A partir de ahora, podremos hacer uso de la clase anterior como si fuese una
excepcin ms del sistema. Por ejemplo, el
mtodo
anterior
acceso_por_indice (double [], int): double se podra programar ahora como:
public static double acceso_por_indice (double [] v, int indice) throws IndiceFueraDeRangoExcepcion{
try {

return v [indice];
}
else { //Caso excepcional:
throw new IndiceFueraDeRangoExcepcion ("El indice " + indice + " no es
una posicion valida");
}
}
catch (IndiceFueraDeRangoExcepcion mi_excepcion)
{ System.out.println(mi_excepcion.toString());
System.out.println(mi_excepcion.getMessage()); throw mi_excepcion;
}
}
Como podemos observar, el mtodo no ha cambiado, salvo en que donde antes utilizbamos
Exception ahora hemos pasado a usar IndiceFueraDeRangoExcepcion.
Por supuesto, al definir la clase IndiceFueraDeRangoExcepcion podamos haber redefinido alguno
de los mtodos de la misma, o haber aadido mtodos nuevos. Por ejemplo, podamos haber
redefinido el mtodo toString (): String en la misma para que mostrase un mensaje distinto al que
muestra en su definicin por defecto:
class IndiceFueraDeRangoExcepcion extends Exception{ public
IndiceFueraDeRangoExcepcion (){
super();
}
public IndiceFueraDeRangoExcepcion (String s){ super(s);
}
public String toString (){
return ("Se ha producido la excepcion " +
this.getClass().getName() + "\n" +
"Con el siguiente mensaje: " + this.getMessage() + "\n");
}
}
Cuando ahora invoquemos al mtodo toString (): String sobre algn objeto de la clase
IndiceFueraDeRangoExcepcion obtendremos una cadena como la siguiente:
Se ha producido la excepcion IndiceFueraDeRangoExcepcion Con el siguiente
mensaje: El indice 575 no es una posicion valida
Por ltimo, recordamos de nuevo que si hubiramos declarado la clase por herencia de la clase
RunTimeException no hubiera sido necesario gestionar o capturar la misma.
En la siguiente Seccin veremos un ejemplo ms complejo de programacin en

Java con excepciones, relacionado con la salida y entrada de informacin
desde ficheros.
UN EJEMPLO DESARROLLADO DE TRABAJO CON EXCEPCIONES

DE LA API DE JAVA
En la siguiente Seccin vamos a ver un ejemplo un poco ms elaborado de
trabajo con excepciones. No nos vamos a reducir a gestionar y capturar una
simple excepcin, sino que desarrollaremos un programa completo que haga la
gestin de las mismas. Tampoco pretende ser una receta de cmo debe ser la
gestin de excepciones, aunque s que puede contener ideas tiles para la
gestin de las mismas.
El programa resulta sencillo. Lo que hace es crear un fichero, de nombre
entrada_salida.txt, y despus volcar varias cadenas de caracteres al mismo
(objetos de tipo String), que luego el mismo programa se encargar de
recuperar.
Las principales clases envueltas en el proceso sern la clase File
(http://java.sun.com/javase/6/docs/api/java/io/File.html ), que nos permite crear y
gestionar
ficheros,
la
clase
FileWriter
(http://java.sun.com/javase/6/docs/api/java/io/FileWriter.html ), que nos permite
abrir un fichero para realizar escritura en el mismo, la clase BufferedWriter
(http://java.sun.com/javase/6/docs/api/java/io/BufferedWriter.html ) que permite
asociarle un bfer de escritura a un flujo de escritura (en este caso, al
FileWriter), facilitando as las operaciones de escritura sobre el mismo, la
clase Scanner (http://java.sun.com/javase/6/docs/api/java/util/Scanner.html )
que ya conocemos, y que nos permitir hacer lectura de distintos tipos de datos
bsicos desde un dispositivo de entrada (por ejemplo, un fichero, o la consola
de MSDOS), y por ltimo, las clases wrapper o envoltorio de alguno de los
tipos
bsicos
de
Java,
como
Double
(http://java.sun.com/javase/6/docs/api/java/lang/Double.html ) o como Integer
(http://java.sun.com/javase/6/docs/api/java/lang/Integer.html ).
Las dems clases que aparecern en el programa sern las excepciones
propias de cada uno de los mtodos que utilicemos de cada una de las clases
anteriores:
import java.io.*;
import java.util.Scanner;
import java.util.NoSuchElementException;
public class Ejemplo_Ficheros{

try{
File file = new File("entrada_salida.txt");
//Lanza NullPointerException, si la cadena es vaca

// Crea el fichero si no existe
boolean success = file.createNewFile();
//Lanza IOException o SecurityException
if (success) {
// El fichero no existe y se crea:
System.out.println("El fichero no existe y se crea");
//Comprueba que el fichero se puede escribir y leer:
System.out.println ("El fichero se puede escribir "
+ file.canWrite());
System.out.println ("El fichero se puede leer "
+ file.canRead());
//Le asociamos al fichero un bfer de escritura:
BufferedWriter file_escribir =
new BufferedWriter (new FileWriter (file));
//Lanza IOException
//Escribimos cadenas de caracteres en el fichero
//Separadas por saltos de lneas:
file_escribir.write("Una primera sentencia:");
//Lanza IOException
file_escribir.newLine();
file_escribir.write("8.5");
//Lanza IOException
file_escribir.write("6");
//Lanza IOException
file_escribir.flush();//Lanza IOException
file_escribir.close();//Lanza IOException
//Abrimos ahora el fichero para lectura
//por medio de la clase Scanner:
Scanner file_lectura =
new Scanner (file);
//Lanza FileNotFoundException
//Leemos cadenas de caracteres del mismo:
String leer = file_lectura.nextLine();
//Lanza IllegalStateException
//o NoSuchElementException
String leer2 = file_lectura.nextLine();

String leer3 = file_lectura.nextLine();
//Intentamos convertir cada cadena
//a su tipo de dato original:
double leer_double;
int leer_int;
leer_double = Double.parseDouble(leer2);
//Lanza NumberFormatException
leer_int = Integer.parseInt (leer3);
//Mostramos por la consola las diversas cadenas:
System.out.println ("La cadena leida es " + leer);
System.out.println ("El double leido " + leer_double);
System.out.println ("El entero leido " +
leer_int);
}
else {
// El fichero ya existe:
System.out.println("El fichero ya existe y no se creo");
}
}
catch (FileNotFoundException f_exception) {
//Excepcion que surge si no encontramos el fichero
//al crear el Scanner
System.out.println ("Las operaciones de lectura no
se han podido llevar a cabo,");
System.out.println ("ya que ha sucedido un problema
al buscar el fichero para lectura");
System.out.println (f_exception.toString());
}
catch (IOException io_exception){
//Excepcion que puede surgir en
//alguna de las operaciones de escritura
System.out.println("Ocurrio algun error de entrad y salida");
System.out.println (io_exception.toString());
}
catch (NumberFormatException nb_exception){
//Excepcion que ocurre al realizar una conversion de una cadena
//de caracteres a un tipo numerico
System.out.println ("Ha ocurrido un error de
conversin de cadenas a numeros");
System.out.println (nb_exception.toString());
}
catch (NoSuchElementException nse_exception){
//Excepcion que ocurre cuando el metodo

//"nextLine(): String" no encuentra una cadena
System.out.println ("No se ha podido encontrar el
siguiente elemento del Scanner");
System.out.println (nse_exception.toString());
}
catch (Exception e_exception){

//Un ultimo bloque que nos permita
//capturar cualquier tipo de excepcion
System.out.println (e_exception.toString());
}
}
}
Algunas consideraciones se pueden hacer sobre el anterior fragmento de
cdigo:
1. En primer lugar, con respecto a la estructura del mismo, se puede observar
como hemos creado un bloque try {...} en el que hemos incluido la mayor
parte de los comandos del programa. El mismo est seguido de una secuencia
de comandos catch (...) {...} que capturan y gestionan cada una de las
excepciones que pueden surgir del bloque try {...}.
2. Tal y como hemos programado los bloques anteriores, en cuanto surja una
excepcin cualquiera en un mtodo, el flujo del programa se dirigir a los
bloques catch (...) {...} que finalizan el mismo, por lo que el programa habr
terminado su ejecucin (frente a esto, podamos haber optado por ir
gestionando las excepciones junto a las llamadas a los mtodos, haciendo que
el flujo del programa continuara aun despus de tener lugar una situacin
excepcional). Como ya hemos mencionado con anterioridad, tal decisin
depende del programador de la aplicacin y del diseo que hagamos de la
misma.
A modo de conclusin del Tema, cabe decir que el uso de excepciones no evita
los errores en programacin. Su utilidad est relacionada ms bien con
informar sobre los errores o situaciones excepcionales que se producen
durante la ejecucin de un programa, y por eso su uso depende en gran
medida del programador de cada aplicacin, y de cmo el mismo quiera tener
constancia de esos errores. Por lo tanto, deben ser entendidas como un
sistema para informar sobre errores que han ocurrido en una aplicacin, y no
como una solucin a los errores en la programacin.

Libro

Cargado por

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Libro

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Libro

Cargado por

Copyright:

Formatos disponibles

TEMA 5. EXCEPCIONES EN JAVA............................................................

3.10 EXCEPCIONES EN JAVA

DEFINICIN DE EXCEPCIONES EN PROGRAMACIN

trate la misma es lo que se conoce generalmente como manejo o gestin de la

El mtodo division_real(double, double): double est correctamente

Value podemos observar que la misma devolver cero en caso de que el

throw new Exception();

Al lanzar dicha excepcin, el flujo de nuestra aplicacin vuelve al cliente de la

Despus de ver los cambios que hemos debido introducir en el mtodo

System.out.println ("El resultado de la division real de " + x +

alguna podra lanzar una excepcin (en nuestro caso, division_real(double,

funcin del bloque catch (...) {...} es precisamente la de capturar (o coger)

En primer lugar, la orden catch es la que comienza el bloque.

b) Seguido de ella podemos encontrar la indicacin catch (Exception

Si lo ejecutamos con una entrada no excepcional, por ejemplo, con

public static void main (String [] args){

flujo de ejecucin se haya introducido en la clusula catch (Exception

permiten enriquecer el comportamiento de los mtodos, ya que por el uso de

1) toString(): String que como ya conocemos pertenece a la clase Object. De

int array_enteros [] = new int [-50];

Declaramos y creamos un array de objetos de la clase Object, pero no

TRABAJANDO CON EXCEPCIONES: DECLARACIN, CONSTRUCCIN,

public static void main (String [] args){

Veamos los cambios que hemos introducido en el mtodo al declarar y

int): double propague la excepcin, y para ello debemos indicar en la cabecera

CAPTURA Y GESTIN DE EXCEPCIONES

En nuestro caso, y ya que nuestro mtodo ha de devolver un double, lo

El elemento en 400 es 0.0

El indice 500 no es una posicion valida

CAPTURA, GESTIN Y PROPAGACIN DE EXCEPCIONES

catch (Exception mi_excepcion)

gestionar la excepcin que nos puede mandar acceso_por_indice (double [],

CMO TRABAJAR CON EXCEPCIONES

En general es difcil dar recetas universales sobre cmo trabajar con

PROGRAMACIN DE EXCEPCIONES PROPIAS EN JAVA

La metodologa para lo mismo es sencilla. Slo debemos declarar una clase

Generalmente, a la hora de declarar una nueva excepcin, buscaremos un

if ((0<=indice) && (indice <v.length)){

En la siguiente Seccin veremos un ejemplo ms complejo de programacin en

UN EJEMPLO DESARROLLADO DE TRABAJO CON EXCEPCIONES

public static void main (String [] args){

//Lanza NullPointerException, si la cadena es vaca

String leer2 = file_lectura.nextLine();

//Excepcion que ocurre cuando el metodo

catch (Exception e_exception){

También podría gustarte

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.