módulo v archivo y excepciones - loboar.com · creación de un programa en java con manejo de...

INSTITUTO de TECNOLOGÍA O. R. T. Analista de Sistemas de Computación Instituto Incorporado a la Enseñanza Oficial (A-763) Taller de Computación VI Yatay 240 - Buenos Aires - República Argentina

1

Asignatura

Taller de Computación VI

Módulo V Archivo y Excepciones

Elaboración

Hugo Sanoguera, Fabián Gentile

Este material pertenece a la materia Taller de Computación VI, de la Carrera de Analista de Sistemas de Computación del INSTITUTO DE TECNOLOGÍA ORT. Todos los derechos reservados. No está permitida la reproducción total o parcial de este apunte, ni su tratamiento informático, ni la transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, por registro u otros métodos, sin el permiso previo de los titulares. 1ra edición Mayo de 2007.


2

UNIDAD DIDÁCTICA V

ÍNDICE UNIDAD DIDÁCTICA V _________________________________________________________ 2

ÍNDICE ____________________________________________________________________________ 2

Introducción y orientaciones para el estudio______________________________________________ 3

Objetivos ___________________________________________________________________________ 3

Aclaraciones previas al estudio_________________________________________________________ 3

Entrada/Salida Estándar______________________________________________________________ 4

Archivos ___________________________________________________________________________ 5

Creación 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 Especificación de las Excepciones disparadas por un método_________________________________________ 23 ¿Cómo Disparar Excepciones ?_________________________________________________________________ 23

Excepciones Chequeadas y de Ejecución ________________________________________________ 24

Apéndice __________________________________________________________________________ 25


3

Introducción y orientaciones para el estudio En el desarrollo de este módulo abordaremos: � Entradas y Salidas en java. � Archivos en java. � Archivos de texto y binarios. � Creación de un programa en Java con manejo de archivos. � Excepciones. Manejo. Tipos � Creación 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 aproximación al manejo de archivos de Texto y Binarios en Java. � Tener una aproximación 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

ejecución, conociendo las etapas intermedias.

Aclaraciones previas al estudio En este módulo, usted encontrará: Contenidos Conceptualizaciones centrales Bibliografía

Usted debe tener presente que los contenidos presentados en el módulo no ahondan profundamente en el tema, sino que pretenden ser un recurso motivador, para que a través de la lectura del material, la bibliografía sugerida, y el desarrollo de las actividades propuestas alcance los objetivos planteados en el presente módulo.


4

Entrada/Salida Estándar Material de Tutorial de Java (Ficheros en Java. www.cica.es/formacion/JavaTut/Cap8)

Los usuarios de Unix, y aquellos familiarizados con las líneas de comandos de otros sistemas como DOS, han utilizado un tipo de entrada/salida conocida comúnmente por entrada/salida estándar . El archivo de entrada estándar ( stdin ) es simplemente el teclado. El archivo de salida estándar ( stdout ) es típicamente la pantalla (o la ventana de la terminal). El archivo de salida de error estándar ( stderr ) también 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 estándar a través 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 métodos read( ) y skip( ). El método 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 métodos print( ) y println( ) con cualquier tipo básico Java como argumento.

Stderr

System.err implementa stderr de la misma forma que stdout. Como con System.out, se tiene acceso a los métodos de PrintStream.

Vamos a ver un pequeño ejemplo de entrada/salida en Java. El código 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(); // Línea en blanco System.err.println( "Contados "+ contador +" bytes en total." ); } }


5

Clases comunes de Entrada/Salida

Además de la entrada por teclado y salida por pantalla, se necesita entrada/salida por archivo, como son:

FileInputStream DataInputStream FileOutputStream DataOutputStream

También existen otras clases para aplicaciones más específicas, que no vamos a tratar, por ser de un uso muy concreto:

PipedInputStream BufferedInputStream PushBackInputStream StreamTokenizer PipedOutputStream BufferedOutputStream

Archivos

Todos los lenguajes de programación tienen alguna forma de interactuar con los sistemas de archivos locales; Java no es una excepción.

Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la entrada/salida directa a archivo es una violación de seguridad de acceso. Muchos usuarios configurarán sus navegadores para permitir el acceso al sistema de archivos, pero otros no.

Por otro lado, si se está desarrollando una aplicación Java para uso interno, probablemente será necesario el acceso directo a archivos.

Antes de realizar acciones sobre un archivo, necesitamos un poco de información sobre ese archivo. La clase File proporciona muchas utilidades relacionadas con Archivos y con la obtención de información básica sobre esos archivos.

Creación 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 sólo se utiliza un archivo en la aplicación, el primer constructor es el mejor. Si en cambio, se utilizan muchos archivos desde un mismo directorio, el segundo o tercer constructor serán más cómodos. Y si el directorio o el archivo es una variable, el segundo constructor será el más útil.


6

Comprobaciones y Utilidades

Una vez creado un objeto File, se puede utilizar uno de los siguientes métodos para reunir información 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()

• Información general del archivo long lastModified() long length()

• Utilidades de directorio boolean mkdir() String[] list() Vamos a desarrollar una pequeña aplicación que muestra información sobre los archivos pasados como argumentos en la línea 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 función 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

Creación de un filtro

Un filtro es un objeto de una clase que implemente el interface FilenameFilter, y tiene que redefinir la única función del interface denominada accept. Esta función devuelve un dato de tipo boolean. En este caso, la hemos definido de forma que si el nombre del archivo termina con una determinada extensión devuelve true en caso contrario devuelve false. La función endsWith de la clase String realiza esta tarea tal como se ve en la porción de código que viene a continuación. La extensión se le pasa al constructor de la clase Filtro para inicializar el miembro dato extensión.

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 extensión .java en el directorio actual, creamos un objeto de la clase Filtro y se lo pasamos a la función 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


8

Streams de Entrada Material de Tutorial de Java (Ficheros en Java. www.cica.es/formacion/JavaTut/Cap8)

Hay muchas clases dedicadas a la obtención de entrada desde un archivo. Este es el esquema de la jerarquía de clases de entrada por archivo:

Objetos FileInputStream

Los objetos FileInputStream típicamente 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" ); //También 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 método 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 número de bytes leídos 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 número de bytes leídos o -1 si se alcanzó el final del stream.


9

Cierre de FileInputStream

Cuando se termina con un archivo, existen dos opciones para cerrarlo: explícitamente, o implícitamente cuando se recicla el objeto (el garbage collector se encarga de ello).

Para cerrarlo explícitamente, se utiliza el método close():

miArchivoSt.close();

Ejemplo: Visualización de un archivo

Si la configuración de la seguridad de Java permite el acceso a archivos, se puede ver el contenido de un archivo en un objeto TextArea. El código 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 // tamaño 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, teléfono y dirección. Si tecleamos un nombre, buscará en el archivo de datos si existe ese nombre y presentará la información que se haya introducido. Para probar, intentar que aparezca la información 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 métodos 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 explícitamente // 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 métodos read() de los objetos FileInputStream. No obstante, también se tiene acceso a otros métodos diseñados 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 método leerá un objeto del tipo pedido.

Para el método 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 están ordenadas jerárquicamente:

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 métodos 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, también 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 método write(). Como con el método 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 método explícito:

miArchivoSt.close();

O, se puede dejar que el sistema cierre el archivo cuando se recicle miArchivoSt.

Ejemplo: Almacenamiento de Información Este programa Telefonos.java, pregunta al usuario una lista de nombres y números de teléfono. Cada nombre y número se añade a un archivo situado en una localización 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 código 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 pequeños, será una buena idea utilizar un stream de salida con buffer. Los streams con buffer ofrecen los mismos métodos de la clase FileOutputStream, pero toda salida se almacena en un buffer. Cuando se llena el buffer, se envía a disco con una única operación de escritura; o, en caso necesario, se puede enviar el buffer a disco en cualquier momento.

Creación de Streams de salida con buffer

Para crear un stream BufferedOutput, primero se necesita un stream FileOutput normal; entonces se le añade 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 explícitamente 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 también 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 métodos 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 explícitamente. 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 métodos write() accesibles por los FileOutputStream también lo son a través de los DataOutputStream. También encontrará métodos 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 función necesaria durante la salida es el método size(). Este método simplemente devuelve el número total de bytes escritos en el archivo. Se puede utilizar size() para ajustar el tamaño de un archivo a múltiplo 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.

Creación 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 sólo lectura ( r ) o de lectura/escritura ( r/w ). Por ejemplo, se puede abrir un archivo de una base de datos para actualización:

RandomAccessFile miRAFile; miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );

Acceso a la Información

Los objetos RandomAccessFile esperan información 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 .

También se tienen muchos métodos para moverse dentro de un archivo:

long getFilePointer();

Devuelve la posición actual del puntero del archivo

void seek( long pos );

Coloca el puntero del archivo en una posición determinada. La posición se da como un desplazamiento en bytes desde el comienzo del archivo. La posición 0 marca el comienzo de ese archivo.


16

long length();

Devuelve la longitud del archivo. La posición length() marca el final de ese archivo.

Actualización de Información

Se pueden utilizar archivos de acceso aleatorio para añadir información a archivos existentes:

miRAFile = new RandomAccessFile( "/tmp/kk.log","rw" ); miRAFile.seek( miRAFile.length() ); // Cualquier write() que hagamos a partir de este punto del código añadirá // información al archivo

Vamos a ver un pequeño ejemplo del programa Log.java , que añade 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 excepción es un evento que ocurre durante la ejecución 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 inválidas 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 Ejecución: son irrecuperables y representan problemas que son detectados por el

sistema de ejecución de Java. Por ejemplo, las excepciones aritméticas (división por cero),excepciones de apuntadores (acceso a un objeto mediante un puntero nulo) y excepciones de indexación (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 dispararán, ni capturadas para su manejo.

• Chequeadas: no son excepciones “De Ejecución” 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 métodos ó 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 podría solucionar sobrescribiendo algún elemento que ya no se usa; si un archivo no puede abrirse, se le podría pedir al usuario que ingrese un nuevo nombre.

Cuando un método dispara una excepción, crea un objeto excepción que contiene información acerca del error ocurrido (tipo de error, estado del programa cuando ocurrió el error). El método entrega el objeto al sistema de ejecución quien es el responsable de encontrar un código 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 código en este lugar throws FileNotFoundException

Falta este código en este lugar throws IOException


18

El compilador detecta que tanto el constructor de la clase InputFile como el método getWord, no especifican ni capturan las excepciones que se generan dentro de su alcance, por lo tanto rechaza la compilación.

in=new FileReader(filename); El nombre pasado como parámetro al constructor de la clase FileReader no existe en el file system, por tanto el constructor disparará la excepción: java.io.FileNotFoundException. c=in.read(); El método getWord() de la clase InputFile lee del objeto FileReader abierto en el constructor de la clase, usando el método read(). Este método dispara la excepción: java.io.IOException si por algún motivo no se puede leer. Al dispararse estas excepciones, el constructor y el método read() de la clase FileReader permiten que los métodos que los invocan capturen dicho error y lo recuperen de una manera apropiada. La clase InputFile, ignora que el constructor y método read() de la clase FileReader disparan excepciones. Sin embargo, Java obliga a que toda excepción 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 método getWord() para que capturen y recuperen el error, ó

• Pasar por alto los errores y darle la oportunidad a los métodos que invoquen a los métodos de InputFile a que recuperen los errores.

Cuando un método dispara una excepción (crea un objeto excepción y se lo entrega al sistema de ejecución de Java), el sistema de ejecución de JAVA busca en la pila de ejecución el código apropiado que maneje el error comenzando por el método que lo produjo y subsiguientemente por los métodos de la pila.

• Un manejador de excepción es apropiado si el tipo de la excepción disparada coincide con la manejada.

Si el sistema de ejecución no encuentra un manejador apropiado en la pila de ejecución, la excepción será atendido por un manejador de default que finaliza la ejecución del programa.


19

Ventajas del Manejo de Excepciones

• Separar el código regular del programa del código que maneja errores. Java permite escribir el flujo principal del código y tratar los casos excepcionales en otro lugar.

• Propagar errores en la pila de ejecución.


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 código específico y recuperadas. Los errores son disparados por problemas más serios, por ejemplo, OutOfMemoryError que no son sencillos de manejar ó errores de hardware. Los errores son disparados por los métodos 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 excepción específica usando el parámetro 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 código propenso a errores pues capturan y manejan excepciones que no fueron previstas y por lo tanto no se manejan correctamente. No son útiles para recuperación 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 múltiples manejadores. 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)); } Excepción de ejecución

El/los bloque/s CATCH La forma de asociar manejadores de excepciones con un bloque TRY es proveyendo uno ó más bloques CATCH inmediatamente después del bloque TRY. try{ ..... } catch (ArrayIndexOutOfBoundsException e) { System.err.println(“Excepción capturada...” + e.getMessage()); } catch (IOException e) { System.err.println(“Excepción capturada...” + e.getMessage()); } El sistema de ejecución de JAVA invoca al manejador de excepciones cuando el manejador es el primero en la pila de ejecución cuyo tipo coincide con el tipo de excepción disparada. El sistema considera que el tipo coincide si puede ser asignado al argumento del manejador.

Dispara un IOException si no puede abrirse el archivo

Dispara un ArrayIndexOutOfBoundsException si el índice es muy chico (número negativo) ó muy grande

Manejador de Excepción Especializado

Manejador de Excepción Especializado


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 código necesario para liberar recursos adentro del bloque FINALLY.

El sistema de ejecución 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: ¿Cómo 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<size; i++) out.println(“Valor en: ”+ i +” = ”+v.elementAt(i)); } catch (ArrayIndexOutOfBoundsException e) { System.err.println(“Excepción capturada...” + e.getMessage()); } catch (IOException e) { System.err.println(“Excepción capturada...” + e.getMessage()); } 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.


23

Especificación de las Excepciones disparadas por un método Si no es apropiado para un método capturar y manejar las excepciones disparadas dentro de su alcance, el método debe especificar en su declaración que dispara excepciones. En algunas situaciones es mejor que un método 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 método de la pila de ejecución que la maneje. public void writeList() throws IOException, ArrayIndexOfBoundsException { PrintWriter out=null; out=new PrintWriter(new FileWriter(“OutFile.txt”)); for (int i=0; i<size; i++){ out.println(“Valor en: ”+ i +” = ”+v.elementAt(i)); out.close();

} }

¿Cómo Disparar Excepciones ? La sentencia THROW es usada por todos los métodos que dispararán 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; }

No es necesario especificarla pues es una excepción de ejecución

El método pop() usa la cláusula throws para declarar que puede disparar un

una EmptyStackException

El método pop() chequea si hay algún elemento en la pila. Si está vacía, el método pop() instancia un objeto EmptyStackException y lo dispara.


24

Excepciones Chequeadas y de Ejecución

• JAVA NO requiere que los métodos capturen ó especifiquen excepciones de ejecución, por

lo tanto los programadores pueden estar tentados a escribir código 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 diseñadores de JAVA obligan a especificar ó declarar todas las excepciones

chequeadas que pueden ser disparadas dentro del alcance de un método, pues estas forman parte de la interface pública de programación del método. Los que invocan a un método deben conocer las excepciones que un método puede disparar con el objetivo de decidir que hacer si esto ocurre. Es por eso que las excepciones junto con los parámetros y el valor de retorno forman parte de la interfaz de programación de un método.

• Las excepciones chequeadas representan información útil sobre la operación 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 conexión ó no se tienen permisos para realizar determinada acción.

• Las excepciones de ejecución representan problemas que son detectados por el sistema

de ejecución. Pueden ocurrir en cualquier lugar del programa y en un programa típico suelen ser numerosas: división por cero, acceder a un objeto mediante un puntero nulo, etc.. Usualmente, el costo de chequear las excepciones de ejecución excede al beneficio de capturarlas ó especificarlas. Es por eso que el compilador NO requiere que se capturen ni especifiquen las excepciones de ejecución, aunque puede hacerse.

• Disparar excepciones de ejecución (RuntimeException) es una forma de evitar documentar

las excepciones que puede disparar un método.


25

Apéndice

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, teléfono y dirección. Si tecleamos un nombre, buscará en el archivo de datos si existe ese nombre y presentará la información que se haya introducido. Para probar, intentar que aparezca la información de pepe. Agenda.txt es un archivo de texto que tiene los siguientes datos (debe tener un dato por línea) 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 <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 );

}

}

}

}

módulo v archivo y excepciones - loboar.com · creación de un programa en java con manejo de...

Documents