taller vi modulo v

INSTITUTO de TECNOLOGA O. R. T. Analista de Sistemas de Computacin Instituto Incorporado a la Enseanza Oficial (A-763) Taller de Computacin VI Yatay 240 - Buenos Aires - Repblica Argentina

1

Asignatura

Taller de Computacin VI

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.


2

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


3

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.


4

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." ); } }


5

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.


6

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 { public static void main( String args[] ) throws IOException { 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." ); } }


7

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


8

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; miArchivo = new File( "/etc/kk" ); 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.


9

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.


10

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();


11

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; miArchivo = new File( "/etc/kk" ); 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].


12

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; public static void main( String args[] ) throws IOException { 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(); }


13

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; // Obtiene un controlador de archivo 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();


14

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; // Obtiene un controlador de archivo 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 writeBoolean( boolean b ); void writeByte( int i ); void writeShort( int i ); void writeChar( int i ); void writeInt( int i ); void writeFloat( float f ); void writeDouble( double d ); void writeBytes( String s ); void 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().


15

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.


16

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 { public static void main( String args[] ) throws IOException { 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(); } }


17

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:

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. in=new FileReader(filename); 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 FileNotFoundException

Falta este cdigo en este lugar throws IOException


18

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.

in=new FileReader(filename); 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.


19

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.


20

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


21

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. PrintWriter out=null; try{ out=new PrintWriter(new FileWriter(OutFile.txt)); for (int i=0; i


22

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() { PrintWriter out=null; try { out=new PrintWriter(new FileWriter(OutFile.txt)); for (int i=0; i


23

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 { PrintWriter out=null; out=new PrintWriter(new FileWriter(OutFile.txt)); for (int i=0; i


24

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.


25

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;

}


26

}

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 " );

try {

while( !"\r".equals( nombre = leeEntrada( System.in ) ) )

{

lista.printDireccion( nombre );

System.out.println(

"Introduzca un nombre o " );

}

} 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 );

}

}

}

}

taller vi modulo v

Documents