Taller VI Modulo V

INSTITUTO de TECNOLOGA O. R. T.
Instituto Incorporado a la Enseanza Oficial (A-763)

Yatay 240 - Buenos Aires - Repblica Argentina
Analista de Sistemas de Computacin

Taller de Computacin VI
Asignatura
Mdulo V
Archivo y Excepciones
Elaboracin
Hugo Sanoguera, Fabin Gentile
Este material pertenece a la materia Taller de Computacin VI, de la Carrera de Analista de Sistemas de
Computacin del INSTITUTO DE TECNOLOGA ORT.
Todos los derechos reservados. No est permitida la reproduccin total o parcial de este apunte, ni su
tratamiento informtico, ni la transmisin de ninguna forma o por cualquier medio, ya sea electrnico,
mecnico, por fotocopia, por registro u otros mtodos, sin el permiso previo de los titulares.
1ra edicin Mayo de 2007.

UNIDAD DIDCTICA V
NDICE
UNIDAD DIDCTICA V _________________________________________________________ 2
NDICE ____________________________________________________________________________ 2
Introduccin y orientaciones para el estudio ______________________________________________ 3
Objetivos ___________________________________________________________________________ 3
Aclaraciones previas al estudio _________________________________________________________ 3
Entrada/Salida Estndar ______________________________________________________________ 4
Archivos ___________________________________________________________________________ 5
Creacin de un filtro _________________________________________________________________ 7
Streams de Entrada __________________________________________________________________ 8
Streams de Salida ___________________________________________________________________ 11
Archivos de Acceso Aleatorio _________________________________________________________ 15
Excepciones________________________________________________________________________ 17
Ventajas del Manejo de Excepciones ____________________________________________________________ 19
Componentes de un Manejador de Excepciones______________________________ 21

El bloque TRY ______________________________________________________________________________ 21
El/los bloque/s CATCH_______________________________________________________________________ 21
El bloque FINALLY _________________________________________________________________________ 22
Especificacin de las Excepciones disparadas por un mtodo _________________________________________ 23
Cmo Disparar Excepciones ?_________________________________________________________________ 23
Excepciones Chequeadas y de Ejecucin ________________________________________________ 24

Apndice __________________________________________________________________________ 25

Introduccin y orientaciones para el estudio

En el desarrollo de este mdulo abordaremos:

Entradas y Salidas en java.

Archivos en java.
Archivos de texto y binarios.
Creacin de un programa en Java con manejo de archivos.
Excepciones. Manejo. Tipos
Creacin de un programa en Java con manejo de excepciones.
Objetivos
Pretendemos que al finalizar de estudiar esta Unidad, el alumno logre:

Conocer las distintas clases para el manejo de Entradas y salidas de Java.

Tener una primera aproximacin al manejo de archivos de Texto y Binarios en Java.
Tener una aproximacin al manejo de excepciones en Lenguaje Java.
Conocer el manejo de archivos y excepciones en Java.
Poder realizar un programa que utiliza archivos y excepciones, desde su escritura hasta su
ejecucin, conociendo las etapas intermedias.
Aclaraciones previas al estudio

En este mdulo, usted encontrar:
Contenidos
Conceptualizaciones centrales
Bibliografa
Usted debe tener presente que los contenidos presentados en el mdulo
no ahondan profundamente en el tema, sino que pretenden ser un recurso
motivador, para que a travs de la lectura del material, la bibliografa
sugerida, y el desarrollo de las actividades propuestas alcance los
objetivos planteados en el presente mdulo.

Entrada/Salida Estndar
Material de Tutorial de Java (Ficheros en Java. www.cica.es/formacion/JavaTut/Cap8)
Los usuarios de Unix, y aquellos familiarizados con las lneas de comandos de otros sistemas
como DOS, han utilizado un tipo de entrada/salida conocida comnmente por entrada/salida
estndar . El archivo de entrada estndar ( stdin ) es simplemente el teclado. El archivo de salida
estndar ( stdout ) es tpicamente la pantalla (o la ventana de la terminal). El archivo de salida de
error estndar ( stderr ) tambin se dirige normalmente a la pantalla, pero se implementa como
otro archivo de forma que se pueda distinguir entre la salida normal y (si es necesario) los
mensajes de error.
La clase System
Java tiene acceso a la entrada/salida estndar a travs de la clase System . En concreto, los tres
Archivos que se implementan son:
Stdin
System.in implementa stdin como una instancia de la clase InputStream . Con System.in , se
accede a los mtodos read( ) y skip( ). El mtodo read( ) permite leer un byte de la entrada.
skip( long n ) , salta n bytes de la entrada.
Stdout
System.out implementa stdout como una instancia de la clase PrintStream. Se pueden utilizar los
mtodos print( ) y println( ) con cualquier tipo bsico Java como argumento.
Stderr
System.err implementa stderr de la misma forma que stdout. Como con System.out, se tiene
acceso a los mtodos de PrintStream.
Vamos a ver un pequeo ejemplo de entrada/salida en Java. El cdigo siguiente miType.java,
que reproduce, o funciona como la utilidad cat de Unix o type de DOS:
import java.io.*;
class miType {
public static void main( String args[] ) throws IOException {
int c;
int contador = 0;
while( (c = System.in.read() ) != '\n' ){
contador++;
System.out.print( (char)c );
}
System.out.println(); // Lnea en blanco
System.err.println( "Contados "+ contador +" bytes en total." );
}
}

Clases comunes de Entrada/Salida

Adems de la entrada por teclado y salida por pantalla, se necesita entrada/salida por archivo,
como son:
FileInputStream
DataInputStream
FileOutputStream
DataOutputStream
Tambin existen otras clases para aplicaciones ms especficas, que no vamos a tratar, por ser de
un uso muy concreto:
PipedInputStream
BufferedInputStream
PushBackInputStream
StreamTokenizer
PipedOutputStream
BufferedOutputStream
Archivos
Todos los lenguajes de programacin tienen alguna forma de interactuar con los sistemas de
archivos locales; Java no es una excepcin.
Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la entrada/salida
directa a archivo es una violacin de seguridad de acceso. Muchos usuarios configurarn sus
navegadores para permitir el acceso al sistema de archivos, pero otros no.
Por otro lado, si se est desarrollando una aplicacin Java para uso interno, probablemente ser
necesario el acceso directo a archivos.
Antes de realizar acciones sobre un archivo, necesitamos un poco de informacin sobre ese
archivo. La clase File proporciona muchas utilidades relacionadas con Archivos y con la obtencin
de informacin bsica sobre esos archivos.
Creacin de un objeto File
Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores siguientes:
File miArchivo;
miArchivo = new File( "/etc/kk" );
o
miArchivo = new File( "/etc","kk" );
o
File miDirectorio = new File( "/etc" );
miArchivo = new File( miDirectorio,"kk" );
El constructor utilizado depende a menudo de otros objetos File necesarios para el acceso. Por
ejemplo, si slo se utiliza un archivo en la aplicacin, el primer constructor es el mejor. Si en
cambio, se utilizan muchos archivos desde un mismo directorio, el segundo o tercer constructor
sern ms cmodos. Y si el directorio o el archivo es una variable, el segundo constructor ser el
ms til.

Comprobaciones y Utilidades
Una vez creado un objeto File, se puede utilizar uno de los siguientes mtodos para reunir
informacin sobre el archivo:
Nombres de archivo
String getName()
String getPath()
String getAbsolutePath()
String getParent()
boolean renameTo( File nuevoNombre )
Comprobaciones
boolean exists()
boolean canWrite()
boolean canRead()
boolean isFile()
boolean isDirectory()
boolean isAbsolute()
Informacin general del archivo
long lastModified()
long length()
Utilidades de directorio
boolean mkdir()
String[] list()
Vamos a desarrollar una pequea aplicacin que muestra informacin sobre los archivos pasados
como argumentos en la lnea de comandos InfoArchivo.java:
import java.io.*;
class InfoArchivo {
if( args.length > 0 ){
for( int i=0; i < args.length; i++ ){
File f = new File( args[i] );
System.out.println( "Nombre: "+f.getName() );
System.out.println( "Camino: "+f.getPath() );
if( f.exists() ){
System.out.print( "Archivo existente " );
System.out.print( (f.canRead() ?" y se puede Leer" : "" ) );
System.out.print( (f.canWrite() ?" y se puese Escribir" : "" ));
System.out.println( "." );
System.out.println( "La longitud del archivo es "+
f.length()+" bytes" );
}
}else
System.out.println( "El archivo no existe." );
}
else
System.out.println( "Debe indicar un archivo." );
}
}

Material de http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/archivos/file.htm
Para obtener la lista de los archivos del directorio actual se crea un nuevo objeto de la clase File
File archivo=new File(".");
Para obtener la lista de los archivos que contiene este directorio se llama a la funcin miembro list,
la cual nos devuelve un array de strings.
String[] listaArchivos=archivo.list();
for(int i=0; i<listaArchivos.length; i++){
System.out.println(listaArchivos[i]);
}
La salida es la siguiente
archivo1.jpr
archivo1.html
ArchivoApp1.java
ArchivoApp1.~jav
Filtro.java
Filtro.~jav
Creacin de un filtro
Un filtro es un objeto de una clase que implemente el interface FilenameFilter, y tiene que redefinir
la nica funcin del interface denominada accept. Esta funcin devuelve un dato de tipo boolean.
En este caso, la hemos definido de forma que si el nombre del archivo termina con una
determinada extensin devuelve true en caso contrario devuelve false. La funcin endsWith de la
clase String realiza esta tarea tal como se ve en la porcin de cdigo que viene a continuacin. La
extensin se le pasa al constructor de la clase Filtro para inicializar el miembro dato extensin.
import java.io.*;
public class Filtro implements FilenameFilter{
String extension;
Filtro(String extension){
this.extension=extension;
}
public boolean accept(File dir, String name){
return name.endsWith(extension);
}
}
Para obtener la lista de archivos con extensin .java en el directorio actual, creamos un objeto de
la clase Filtro y se lo pasamos a la funcin list miembro de la clase File.
listaArchivos=archivo.list(new Filtro(".java"));
for(int i=0; i<listaArchivos.length; i++){
System.out.println(listaArchivos[i]);
}
La salida es ahora la siguiente

ArchivoApp1.java
Filtro.java

Streams de Entrada
Material de Tutorial de Java (Ficheros en Java. www.cica.es/formacion/JavaTut/Cap8)
Hay muchas clases dedicadas a la obtencin de entrada desde un archivo. Este es el esquema de
la jerarqua de clases de entrada por archivo:
Objetos FileInputStream
Los objetos FileInputStream tpicamente representan Archivos de texto accedidos en orden
secuencial, byte a byte. Con FileInputStream, se puede elegir acceder a un byte, varios bytes o al
archivo completo.
Apertura de un FileInputStream
Para abrir un FileInputStream sobre un archivo, se le da al constructor un String o un objeto File:
FileInputStream mi ArchivoSt;
miArchivoSt = new FileInputStream( "/etc/kk" );
//Tambin se puede utilizar:
File miArchivo FileInputStream miArchivoSt;
miArchivoSt = new FileInputStream(miArchivo );
Lectura de un FileInputStream
Una vez abierto el FileInputStream, se puede leer de l. El mtodo read() tiene muchas opciones:
int read();
Lee un byte y devuelve -1 al final del stream.
int read( byte b[] );
Llena todo el array, si es posible. Devuelve el nmero de bytes ledos o -1 si se alcanz el final del
stream.
int read( byte b[], int offset, int longitud );
Lee longitud bytes en b comenzando por b[offset]. Devuelve el nmero de bytes ledos o -1 si se
alcanz el final del stream.

Cierre de FileInputStream
Cuando se termina con un archivo, existen dos opciones para cerrarlo: explcitamente, o
implcitamente cuando se recicla el objeto (el garbage collector se encarga de ello).
Para cerrarlo explcitamente, se utiliza el mtodo close():
miArchivoSt.close();
Ejemplo: Visualizacin de un archivo
Si la configuracin de la seguridad de Java permite el acceso a archivos, se puede ver el
contenido de un archivo en un objeto TextArea. El cdigo siguiente contiene los elementos
necesarios para mostrar un archivo:
FileInputStream fis;
TextArea ta;
public void init() {
byte b[] = new byte[1024];
// El buffer de lectura se debe hacer lo suficientemente grande o esperar a saber el
// tamao del archivo
int i;
String s;
try {
fis = new FileInputStream( "/etc/kk" );
} catch( FileNotFoundException e ) {
/* Hacer algo */
}
try {
i = fis.read( b );
} catch( IOException e ) {
/* Hacer algo */
}
s = new String( b,0 );
ta = new TextArea( s,5,40 );
add( ta );
}
Hemos desarrollado un ejemplo, Agenda.java (ver Apendice), en el que partimos de un archivo
agenda.txt que dispone de los datos que nosotros deseamos de nuestros amigos, como son:
nombre, telfono y direccin. Si tecleamos un nombre, buscar en el archivo de datos si existe
ese nombre y presentar la informacin que se haya introducido. Para probar, intentar que
aparezca la informacin de pepe.
Objetos DataInputStream
Los objetos DataInputStream se comportan como los FileInputStream. Los streams de datos
pueden leer cualquiera de las variables de tipo nativo, como floats, ints o chars. Generalmente se
utilizan DataInputStream con Archivos binarios.

Apertura y cierre de DataInputStream

Para abrir y cerrar un objeto DataInputStream, se utilizan los mismos mtodos que para
FileInputStream:
DataInputStream miDStream;
FileInputStream miFStream;
// Obtiene un controlador de archivo
miFStream = new FileInputStream "/etc/ejemplo.dbf" );
//Encadena un archivo de entrada de datos
miDStream = new DataInputStream( miFStream );
// Ahora se pueden utilizar los dos streams de entrada para
// acceder al archivo (si se quiere...)
miFStream.read( b );
i = miDStream.readInt();
// Cierra el archivo de datos explcitamente
// Siempre se cierra primero el archivo stream de mayor nivel
miDStream.close();
miFStream.close();
Lectura de un DataInputStream
Al acceder a un archivo como DataInputStream, se pueden utilizar los mismos mtodos read() de
los objetos FileInputStream. No obstante, tambin se tiene acceso a otros mtodos diseados
para leer cada uno de los tipos de datos:
byte readByte()
int readUnsignedByte()
short readShort()
int readUnsignedShort()
char readChar()
int readInt()
long readLong()
float readFloat()
double readDouble()
String readLine()
Cada mtodo leer un objeto del tipo pedido.
Para el mtodo String readLine(), se marca el final de la cadena con \n, \r, \r\n o con EOF.
Para leer un long, por ejemplo:
long numeroSerie;
...
numeroSerie = miDStream.readLong();
10

Streams de Salida
La contrapartida necesaria de la lectura de datos es la escritura de datos. Como con los Streams
de entrada, las clases de salida estn ordenadas jerrquicamente:
Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams

de entrada que se han visto. En los Archivosfuente del directorio $JAVA_HOME/src/java/io se
puede ver el uso y mtodos de estas clases, as como de los streams de entrada ($JAVA_HOME
es el directorio donde se haya instalado el Java Development Kit, en sistemas UNIX).
ObjetosFileOutputStream
Los objetos FileOutputStream son tiles para la escritura de Archivos de texto. Como con los
Archivos de entrada, primero se necesita abrir el archivo para luego escribir en l.
Apertura de un FileOutputStream
Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un
archivo stream de entrada. Se le da al constructor un String o un objeto File.
FileOutputStream miArchivoSt;
miArchivoSt = new FileOutputStream( "/etc/kk" );
Como con los streams de entrada, tambin se puede utilizar:
File miArchivo, FileOutputStream miArchivoSt;

miArchivoSt = new FileOutputStream( miArchivo );
Escritura en un FileOutputStream
Una vez abierto el archivo, se pueden escribir bytes de datos utilizando el mtodo write(). Como
con el mtodo read() de los streams de entrada, tenemos tres posibilidades:
void write( int b ); //Escribe un byte.
void write( byte b[] ); //Escribe todo el array, si es posible.
void write( byte b[], int offset, int longitud );
//Escribe longitud bytes en b comenzando por b[offset].
11

Cierre de FileOutputStream
Cerrar un stream de salida es similar a cerrar streams de entrada. Se puede utilizar el mtodo
explcito:
miArchivoSt.close();
O, se puede dejar que el sistema cierre el archivo cuando se recicle miArchivoSt.
Ejemplo: Almacenamiento de Informacin
Este programa Telefonos.java, pregunta al usuario una lista de nombres y nmeros de telfono.
Cada nombre y nmero se aade a un archivo situado en una localizacin fija. Para indicar que se
ha introducido toda la lista, el usuario especifica "Fin" ante la solicitud de entrada del nombre.
Una vez que el usuario ha terminado de teclear la lista, el programa crear un archivo de salida
que se mostrar en pantalla o se imprimir.
Por ejemplo:
95-4751232,Juanita
564878,Luisa
123456,Pepe
347698,Antonio
91-3547621,Maria
El cdigo fuente del programa es el siguiente:
import java.io.*;
class Telefonos {
static FileOutputStream fos;
public static final int longLinea = 81;
byte tfno[] = new byte[longLinea];
byte nombre[] = new byte[longLinea];
fos = new FileOutputStream( "telefono.dat" );
while( true ){
System.err.println( "Teclee un nombre ('Fin' termina)" );
leeLinea( nombre );
if( "fin".equalsIgnoreCase( new String( nombre,0,0,3 ) ) )
break;
System.err.println( "Teclee el numero de telefono" );
leeLinea( tfno );
for( int i=0; tfno[i] != 0; i++ )
fos.write( tfno[i] );
fos.write( ',' );
for( int i=0; nombre[i] != 0; i++ )
fos.write( nombre[i] );
fos.write( '\n' );
}
fos.close();
}
12

private static void leeLinea( byte linea[] ) throws IOException {

int b = 0;
int i = 0;
while( (i < ( longLinea-1) ) && ( ( b = System.in.read() ) != '\n' ) ){
linea[i++] = (byte)b;
linea[i] = (byte)0;
}
}
Streams de salida con buffer
Si se trabaja con gran cantidad de datos, o se escriben muchos elementos pequeos, ser una
buena idea utilizar un stream de salida con buffer. Los streams con buffer ofrecen los mismos
mtodos de la clase FileOutputStream, pero toda salida se almacena en un buffer. Cuando se
llena el buffer, se enva a disco con una nica operacin de escritura; o, en caso necesario, se
puede enviar el buffer a disco en cualquier momento.
Creacin de Streams de salida con buffer
Para crear un stream BufferedOutput, primero se necesita un stream FileOutput normal; entonces
se le aade un buffer al stream:
FileOutputStream miFileStream;
BufferdOutpurStream miBufferStream;
miFileStream = new FileOutputStream( "/tmp/kk" );
// Encadena un stream de salida con buffer
miBufferStream = new BufferedOutputStream( miFileStream );
Volcado y Cierre de Streams de salida con buffer
Al contrario que los streams FileOutput, cada escritura al buffer no se corresponde con
una escritura en disco. A menos que se llene el buffer antes de que termine el programa,
cuando se quiera volcar el buffer explcitamente se debe hacer mediante una llamada a
flush():
// Se fuerza el volcado del buffer a disco
miBufferStream.flush();
// Cerramos el archivo de datos. Siempre se ha de cerrar
// primero el archivo stream de mayor nivel
miBufferStream.close();
miFileStream.close();
13

Streams DataOutput
Java tambin implementa una clase de salida complementaria a la clase DataInputStream. Con la
clase DataOutputStream, se pueden escribir datos binarios en un archivo.
Apertura y cierre de objetos DataOutputStream
Para abrir y cerrar objetos DataOutputStream, se utilizan los mismos mtodos que para
los objetos FileOutputStream:
DataOutputStream miDataStream;
FileOutputStream miFileStream;
BufferedOutputStream miBufferStream;
miFileStream = new FileOutputStream( "/tmp/kk" );
// Encadena un stream de salida con buffer (por eficiencia)
miBufferStream = new BufferedOutputStream( miFileStream );
// Encadena un archivo de salida de datos
miDataStream = new DataOutputStream( miBufferStream );
// Ahora se pueden utilizar los dos streams de entrada para
// acceder al archivo (si se quiere)
miBufferStream.write( b );
miDataStream.writeInt( i );
// Cierra el archivo de datos explcitamente. Siempre se cierra
// primero el archivo stream de mayor nivel
miDataStream.close();
miBufferStream.close();
miFileStream.close();
Escritura en un objeto DataOutputStream
Cada uno de los mtodos write() accesibles por los FileOutputStream tambin lo son a travs de
los DataOutputStream. Tambin encontrar mtodos complementarios a los de DataInputStream:
void
void
void
void
void
void
void
void
void
writeBoolean( boolean b );
writeByte( int i );
writeShort( int i );
writeChar( int i );
writeInt( int i );
writeFloat( float f );
writeDouble( double d );
writeBytes( String s );
writeChars( string s );
Para las cadenas, se tienen dos posibilidades: bytes y caracteres. Hay que recordar que los bytes
son objetos de 8 bits y los caracteres lo son de 16 bits. Si nuestras cadenas utilizan caracteres
Unicode, debemos escribirlas con writeChars().
14

Contabilidad de la salida
Otra funcin necesaria durante la salida es el mtodo size(). Este mtodo simplemente devuelve
el nmero total de bytes escritos en el archivo. Se puede utilizar size() para ajustar el tamao de
un archivo a mltiplo de cuatro. Por ejemplo, de la forma siguiente:
. . .
int numBytes = miDataStream.size() % 4;
for( int i=0; i < numBytes; i++ )
miDataStream.write( 0 );
. . .
Archivos de Acceso Aleatorio

A menudo, no se desea leer un archivo de principio a fin; sino acceder al archivo como una base
de datos, donde se salta de un registro a otro; cada uno en diferentes partes del archivo. Java
proporciona una clase RandomAccessFile para este tipo de entrada/salida.
Creacin de un Archivo de Acceso Aleatorio
Hay dos posibilidades para abrir un archivo de acceso aleatorio:
Con el nombre del archivo:
miRAFile = new RandomAccessFile( String nombre, String modo );
Con un objeto File:
miRAFile = new RandomAccessFile( File archivo, String modo );
El argumento modo determina si se tiene acceso de slo lectura ( r ) o de lectura/escritura ( r/w ).
Por ejemplo, se puede abrir un archivo de una base de datos para actualizacin:
RandomAccessFile miRAFile;
miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );
Acceso a la Informacin
Los objetos RandomAccessFile esperan informacin de lectura/escritura de la misma manera que
los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read( ) y write( ) de las
clases DataInputStream y DataOutputStream .
Tambin se tienen muchos mtodos para moverse dentro de un archivo:
long getFilePointer();
Devuelve la posicin actual del puntero del archivo
void seek( long pos );
Coloca el puntero del archivo en una posicin determinada. La posicin se da como un
desplazamiento en bytes desde el comienzo del archivo. La posicin 0 marca el comienzo de ese
archivo.
15

long length();
Devuelve la longitud del archivo. La posicin length() marca el final de ese archivo.
Actualizacin de Informacin
Se pueden utilizar archivos de acceso aleatorio para aadir informacin a archivos existentes:
miRAFile = new RandomAccessFile( "/tmp/kk.log","rw" );
miRAFile.seek( miRAFile.length() );
// Cualquier write() que hagamos a partir de este punto del cdigo aadir
// informacin al archivo
Vamos a ver un pequeo ejemplo del programa Log.java , que aade una cadena a un archivo
existente:
import java.io.*;
// Cada vez que ejecutemos este programita, se incorporara una nueva
// linea al archivo de log que se crea la primera vez que se ejecuta
class Log {
RandomAccessFile miRAFile;
String s = "Informacion a incorporar\nTutorial de Java\n";
// Abrimos el archivo de acceso aleatorio
miRAFile = new RandomAccessFile( "/tmp/java.log","rw" );
// Nos vamos al final del archivo
miRAFile.seek( miRAFile.length() );
// Incorporamos la cadena al archivo
miRAFile.writeBytes( s );
// Cerramos el archivo
miRAFile.close();
}
}
16

Excepciones
Material del curso de Java de la Prof. Claudia Queiruga (clase8.pdf. fuente www.linti.unlp.edu.ar/).
Una excepcin es un evento que ocurre durante la ejecucin de un programa y que

interrumpe el flujo normal de instrucciones.
Java usa excepciones para proveer manejo de errores a sus programas.
Ej.: acceso a posiciones invlidas de un arreglo, falta de memoria en el sistema, abrir un archivo
inexistente en el file system, etc.
En Java las excepciones se clasifican en:
De Ejecucin: son irrecuperables y representan problemas que son detectados por el
sistema de ejecucin de Java. Por ejemplo, las excepciones aritmticas (divisin por
cero),excepciones de apuntadores (acceso a un objeto mediante un puntero nulo) y
excepciones de indexacin (acceso a un elemento de un arreglo con un ndice muy chico
demasiado grande). JAVA no requiere que stas excepciones sean especificadas como
que se dispararn, ni capturadas para su manejo.
Chequeadas: no son excepciones De Ejecucin y son chequeadas por el compilador.
Son errores menos severos que los anteriores, son recuperables. El compilador JAVA
verifica que stas excepciones sean especificadas o capturadas. Java requiere que los
mtodos bien capturen (por ej. para recuperar el estado de error) o especifiquen todas
las excepciones chequeadas que pueden producirse dentro de su alcance. Por ej.: si se
intenta agregar un nuevo elemento en una estructura de datos que est llena, se podra
solucionar sobrescribiendo algn elemento que ya no se usa; si un archivo no puede
abrirse, se le podra pedir al usuario que ingrese un nuevo nombre.
Cuando un mtodo dispara una excepcin, crea un objeto excepcin que contiene informacin
acerca del error ocurrido (tipo de error, estado del programa cuando ocurri el error). El mtodo
entrega el objeto al sistema de ejecucin quien es el responsable de encontrar un cdigo
apropiado para manejar el error. Ejemplo:
Falta este cdigo en este lugar
throws FileNotFoundException
import java.io.*;
public class InputFile {
private FileReader in;
public InputFile (String filename)
in=new FileReader(filename);
}
public String getWord()

{
int c;
StringBuffer buf=new StringBuffer();
do {
c=in.read();
if (Character.isWhitespace((char)c))
return buf.toString();
else
buf.append((char)c)
}while (c!=-1)
return buf.toString();
}
}
Si compilamos la clase InputFile,

el compilador nos da los
siguientes dos errores:
InputFile.java: 11: Warning:
Exception
java.io.FileNotFoundException
must be caught, or it must be
declared in throws clause of
this method.
InputFile.java: 19: Warning:
Exception
java.io.IOException must be
caught, or it must be declared
in throws clause of this
method.
c=in.read( );
Falta este cdigo en este lugar

throws IOException
17

El compilador detecta que tanto el constructor de la clase InputFile como el mtodo getWord, no
especifican ni capturan las excepciones que se generan dentro de su alcance, por lo tanto
rechaza la compilacin.
El nombre pasado como parmetro al constructor de la clase FileReader no existe en el file
system, por tanto el constructor disparar la excepcin: java.io.FileNotFoundException.
c=in.read();
El mtodo getWord() de la clase InputFile lee del objeto FileReader abierto en el constructor de la
clase, usando el mtodo read(). Este mtodo dispara la excepcin: java.io.IOException si por
algn motivo no se puede leer.
Al dispararse estas excepciones, el constructor y el mtodo read() de la clase FileReader permiten
que los mtodos que los invocan capturen dicho error y lo recuperen de una manera apropiada.
La clase InputFile, ignora que el constructor y mtodo read() de la clase FileReader disparan
excepciones. Sin embargo, Java obliga a que toda excepcin chequeda sea capturada
especificada. Por lo tanto, la clase InputFile no compila.
En este punto tenemos dos opciones:
Arreglar al constructor de la clase InputFile y al mtodo getWord() para que capturen y

recuperen el error,
Pasar por alto los errores y darle la oportunidad a los mtodos que invoquen a los mtodos
de InputFile a que recuperen los errores.
Cuando un mtodo dispara una excepcin (crea un objeto excepcin y se lo entrega al sistema de
ejecucin de Java), el sistema de ejecucin de JAVA busca en la pila de ejecucin el cdigo
apropiado que maneje el error comenzando por el mtodo que lo produjo y subsiguientemente por
los mtodos de la pila.
Un manejador de excepcin es apropiado si el tipo de la excepcin disparada coincide con

la manejada.
Si el sistema de ejecucin no encuentra un manejador apropiado en la pila de ejecucin, la

excepcin ser atendido por un manejador de default que finaliza la ejecucin del programa.
18

Ventajas del Manejo de Excepciones

Separar el cdigo regular del programa del cdigo que maneja errores.
Java permite escribir el flujo principal del cdigo y tratar los casos excepcionales en otro lugar.
Propagar errores en la pila de ejecucin.
19

Agrupar y Diferenciar Tipos de Errores.
Usualmente las excepciones se
Las excepciones son disparadas cuando ocurren condiciones anormales, que frecuentemente
pueden ser manejadas por un cdigo especfico y recuperadas.
Los errores son disparados por problemas ms serios, por ejemplo, OutOfMemoryError que no
son sencillos de manejar errores de hardware. Los errores son disparados por los mtodos de la
API JAVA o por la JVM.
Una manera de capturar excepciones es capturar solamente aquellas que son instancias de
clases hojas.
Por ejemplo:
catch (InvalidIndexException e) {
.........
}
Otra forma, es capturar un error basado en su grupo tipo general, especificando alguna de las
superclases de excepciones.
Por ejemplo:
catch (ArrayException e) {
.........
}
Se puede averiguar la excepcin especfica usando el parmetro e.
Se puede establecer un manejador muy general que capture cualquier tipo de excepciones.
Por ejemplo:
catch (Exception e) {
.........
}
Los manejadores de excepciones muy generales hacen el cdigo propenso a errores pues
capturan y manejan excepciones que no fueron previstas y por lo tanto no se manejan
correctamente. No son tiles para recuperacin de errores
20

Componentes de un Manejador de Excepciones

El bloque TRY
try {
sentencias JAVA
}
Las sentencias JAVA que pueden disparar excepciones deben estar encerradas dentro
de un bloque try.
Para construir un manejador de excepciones es posible:
Encerrar individualmente cada una de las sentencias JAVA que pueden disparar
excepciones en un bloque try propio y proveer manejadores de excepciones individuales
Agrupar las sentencias que pueden disparar excepciones en un nico bloque Try y
asociarle mltiples manejadores.
Dispara un IOException si no puede

abrirse el archivo
PrintWriter out=null;
try{
out=new PrintWriter(new FileWriter(OutFile.txt));
for (int i=0; i<size; i++)
out.println(Valor en: + i + = +v.elementAt(i));
}
Excepcin de ejecucin
Dispara un ArrayIndexOutOfBoundsException
si el ndice es muy chico (nmero negativo) muy grande
El/los bloque/s CATCH

La forma de asociar manejadores de excepciones con un bloque TRY es proveyendo uno ms
bloques CATCH inmediatamente despus del bloque TRY.
Manejador de
try{
.....
Excepcin
Especializado
} catch (ArrayIndexOutOfBoundsException e) {
System.err.println(Excepcin capturada... + e.getMessage());
} catch (IOException e) {
}
Manejador de
Excepcin
Especializado
El sistema de ejecucin de JAVA invoca al manejador de excepciones cuando el manejador es el

primero en la pila de ejecucin cuyo tipo coincide con el tipo de excepcin disparada. El sistema
considera que el tipo coincide si puede ser asignado al argumento del manejador.
21

El bloque FINALLY
El ltimo paso para definir un manejador de excepciones es liberar recursos antes de que el
control sea pasado a otra parte del programa.
Esto se hace, escribiendo el cdigo necesario para liberar recursos adentro del bloque FINALLY.
El sistema de ejecucin siempre ejecuta las sentencias del bloque FINALLY
independientemente de lo que sucedi en el bloque TRY.
finally {
if (out !=null){
System.out.println(Cerrando PrintWriter);
out.close();
} else {
System.ou.println(PRintWriter no fue abierto);
}
}
Si no est el bloque FINALLY: Cmo se cierra el PrintWriter si no se provee un manejador de
excepciones para ArrayIndexOutOfBoundsException?
Ejemplo Completo
public void writeList() {
try {
for (int i=0; i<size; i++)
} catch (ArrayIndexOutOfBoundsException e) {
} catch (IOException e) {
} finally {
if (out !=null){
System.out.println(Cerrando PrintWriter);
out.close();
} else {
System.ou.println(PRintWriter no fue abierto);
}
}
}
El bloque TRY tiene tres formas posibles de terminar:
1. El constructor de FileWriter falla y dispara una IOException (el usr. No tiene permiso de
escritura, el disco est lleno, etc).
2. La sentencia v.elementAt(i) falla y dispara una ArrayIndexOutOfBoundsException.
3. No sucede ninguna falla y el bloque TRY termina exitosamente.
22

Especificacin de las Excepciones disparadas por un mtodo

Si no es apropiado para un mtodo capturar y manejar las excepciones disparadas dentro de su
alcance, el mtodo debe especificar en su declaracin que dispara excepciones.
En algunas situaciones es mejor que un mtodo propague las excepciones, por ejemplo si se est
implementando un paquete de clases, es posible que no se puedan preveer las necesidades de
todos los usuarios del paquete. En este caso, es mejor no capturar las excepciones y permitir a un
mtodo de la pila de ejecucin que la maneje.
public void writeList() throws IOException, ArrayIndexOfBoundsException {

for (int i=0; i<size; i++){
out.close();
}
}
No es necesario especificarla pues es una
excepcin de ejecucin
Cmo Disparar Excepciones ?

La sentencia THROW es usada por todos los mtodos que dispararn excepciones y requiere
como nico argumento un objeto throwable.
public Object pop( ) throws EmptyStackException {
Object obj;
if (size ==0)
throw new EmptyStackException();
obj = objectAt(size -1);
setObjectAt(size 1, null);
size--;
return obj;
}
El mtodo pop() usa la clusula throws

para declarar que puede disparar un
una EmptyStackException
El mtodo pop() chequea si hay algn elemento en la pila. Si est vaca,

el mtodo pop() instancia un objeto EmptyStackException y lo dispara.
23

Excepciones Chequeadas y de Ejecucin
JAVA NO requiere que los mtodos capturen especifiquen excepciones de ejecucin, por
lo tanto los programadores pueden estar tentados a escribir cdigo que solamente dispare
este tipo de excepciones hacer que todas sus excepciones sean subclase de la clase
RuntimeException. Aparentemente esto puede ser beneficioso para el programador, sin
embargo puede causar problemas para el usuario de estas clases.
Los diseadores de JAVA obligan a especificar declarar todas las excepciones

chequeadas que pueden ser disparadas dentro del alcance de un mtodo, pues estas
forman parte de la interface pblica de programacin del mtodo. Los que invocan a un
mtodo deben conocer las excepciones que un mtodo puede disparar con el objetivo de
decidir que hacer si esto ocurre. Es por eso que las excepciones junto con los parmetros
y el valor de retorno forman parte de la interfaz de programacin de un mtodo.
Las excepciones chequeadas representan informacin til sobre la operacin de un pedido

realizado legalmente, sobre el que llamador no tiene control y sobre el que necesita ser
informado. Por ej.: el file system est lleno, el extremo final cerr la conexin no se
tienen permisos para realizar determinada accin.
Las excepciones de ejecucin representan problemas que son detectados por el sistema
de ejecucin. Pueden ocurrir en cualquier lugar del programa y en un programa tpico
suelen ser numerosas: divisin por cero, acceder a un objeto mediante un puntero nulo,
etc.. Usualmente, el costo de chequear las excepciones de ejecucin excede al beneficio
de capturarlas especificarlas. Es por eso que el compilador NO requiere que se capturen
ni especifiquen las excepciones de ejecucin, aunque puede hacerse.
Disparar excepciones de ejecucin (RuntimeException) es una forma de evitar documentar

las excepciones que puede disparar un mtodo.
24

Apndice
Ejemplo de una agenda en java utilizando Streams y Excepciones.
Hemos desarrollado un ejemplo, Agenda.java en el que partimos de un archivo agenda.txt que
dispone de los datos que nosotros deseamos de nuestros amigos, como son: nombre, telfono y
direccin. Si tecleamos un nombre, buscar en el archivo de datos si existe ese nombre y
presentar la informacin que se haya introducido. Para probar, intentar que aparezca la
informacin de pepe.
Agenda.txt es un archivo de texto que tiene los siguientes datos (debe tener un dato por lnea)
pepe
45551234
Santa fe
1000
2a
jose
47840055
Cabildo
1500
4c
Carlos
47819911
yatay
240
pb
// Agenda.java Copyright (c) 1996, Agustin Froufe Creacion: 06-Oct-1996
import java.io.*;
class Direccion {
protected String nombre;
protected String telefono;
protected String direccion;
Direccion( String n,String t,String d ) {
nombre = n;
telefono = t;
direccion = d;
}
public String getNombre() { return( nombre ); }
public String getTelefono() { return( telefono );}
public String getDireccion() { return( direccion );}
public void print() {
System.out.println( nombre+" "+telefono+" "+ direccion );
}
}
class DireccionArray {
protected Direccion lista[];
final int max = 128;
int tamano = 0;
DireccionArray() { lista = new Direccion[max]; }
void printDireccion( String nombre ) {
for(int i=0; i < tamano; i++ )
{
if( lista[i].getNombre().indexOf( nombre ) != -1 )
lista[i].print();
}
}
void addDireccion( Direccion direccion ) {
if( tamano == max ) System.exit( 1 );
lista[tamano++] = direccion;
}
25

}
public class Agenda {
DireccionArray lista;
FileInputStream agArchivo;
final int longLinea = 32;
public static void main( String argv[] ) {
Agenda agenda = new Agenda();
agenda.bucle();
}
Agenda() { lista = cargaDirecciones(); }
void bucle() {
String nombre;
System.out.println( "Introduzca un nombre o <Enter>" );
try {
while( !"\r".equals( nombre = leeEntrada( System.in ) ) )
{
lista.printDireccion( nombre );
System.out.println(
"Introduzca un nombre o <Enter>" );
}
} catch( Exception e ) { ; }
}
String leeEntrada( InputStream entrada ) throws IOException {
byte chars[] = new byte[longLinea];
int contador = 0;
while( contador < longLinea &&
( chars[contador++] = (byte)entrada.read() ) != '\n' )
if( chars[contador-1] == -1 )
return( null );
return( new String( chars,0,0,contador-1 ) );
}
Direccion cargaDireccion() throws IOException {
String nombre = leeEntrada( agArchivo );
if( nombre == null )
return( null );
String telefono = leeEntrada( agArchivo );
String direccion = leeEntrada( agArchivo ) + "\n " +
leeEntrada( agArchivo ) + "\n " +
leeEntrada( agArchivo );
return( new Direccion( nombre,telefono,direccion ) );
}
DireccionArray cargaDirecciones() {
DireccionArray lista = new DireccionArray();
Direccion nuevaDireccion;
try {
agArchivo = new FileInputStream( "agenda.txt" );
} catch( FileNotFoundException e ) {
System.out.println( "No hay archivo de Agenda" );
return( lista );
}
while( true ) {
try {
nuevaDireccion = cargaDireccion();
if( nuevaDireccion == null )
return( lista );
lista.addDireccion( nuevaDireccion );
} catch( Exception e ) {
System.out.println( "Error cargando Agenda " );
System.exit( 1 );
}
}
}
}
26

Taller VI Modulo V

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Taller VI Modulo V

Caricato da

Copyright:

Formati disponibili

INSTITUTO de TECNOLOGA O. R. T.

Instituto Incorporado a la Enseanza Oficial (A-763)

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Componentes de un Manejador de Excepciones______________________________ 21

Excepciones Chequeadas y de Ejecucin ________________________________________________ 24

Analista de Sistemas de Computacin

Introduccin y orientaciones para el estudio

Entradas y Salidas en java.

Conocer las distintas clases para el manejo de Entradas y salidas de Java.

Aclaraciones previas al estudio

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Clases comunes de Entrada/Salida

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

La salida es ahora la siguiente

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Apertura y cierre de DataInputStream

Analista de Sistemas de Computacin

Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams

File miArchivo, FileOutputStream miArchivoSt;

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

private static void leeLinea( byte linea[] ) throws IOException {

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Archivos de Acceso Aleatorio

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Una excepcin es un evento que ocurre durante la ejecucin de un programa y que

public String getWord()

Si compilamos la clase InputFile,

Falta este cdigo en este lugar

Analista de Sistemas de Computacin

Arreglar al constructor de la clase InputFile y al mtodo getWord() para que capturen y

Un manejador de excepcin es apropiado si el tipo de la excepcin disparada coincide con

Si el sistema de ejecucin no encuentra un manejador apropiado en la pila de ejecucin, la

Analista de Sistemas de Computacin

Ventajas del Manejo de Excepciones

Propagar errores en la pila de ejecucin.

Analista de Sistemas de Computacin

Agrupar y Diferenciar Tipos de Errores.

Usualmente las excepciones se

Analista de Sistemas de Computacin

Componentes de un Manejador de Excepciones

Dispara un IOException si no puede

El/los bloque/s CATCH

El sistema de ejecucin de JAVA invoca al manejador de excepciones cuando el manejador es el

Analista de Sistemas de Computacin

Analista de Sistemas de Computacin

Especificacin de las Excepciones disparadas por un mtodo

public void writeList() throws IOException, ArrayIndexOfBoundsException {

Cmo Disparar Excepciones ?

El mtodo pop() usa la clusula throws

El mtodo pop() chequea si hay algn elemento en la pila. Si est vaca,

Analista de Sistemas de Computacin

Excepciones Chequeadas y de Ejecucin

Los diseadores de JAVA obligan a especificar declarar todas las excepciones

Las excepciones chequeadas representan informacin til sobre la operacin de un pedido

Disparar excepciones de ejecucin (RuntimeException) es una forma de evitar documentar

Analista de Sistemas de Computacin