Unidad 1. Manejo de ficheros 1.1. Introducción. 1.2. Clases asociadas a las operaciones de gestión...

Unidad 1.Manejo de ficheros1.1. Introducción.1.2. Clases asociadas a las operaciones de gestión de ficheros.1.3.Flujos o streams. Tipos.1.4. Formas de acceso a un fichero.1.5. Operaciones sobre ficheros.1.6. Clases para gestión de flujos de datos desde/hacia ficheros.1.7. Trabajo con ficheros XML.1.8. Excepciones y tratamiento

Fichero. Conjunto de datos almacenados en un dispositivo (DD, pen drive...)

Los datos almacenados en ficheros son no volátiles.

Los ficheros dentro de una carpeta tienen nombre único y su extensión identifica el tipo de archivo (pdf, doc, htm, gif...)

Un fichero está formado por líneas, registros (campos),...

1.1 Introducción

Clase File. Proporciona utilidades relacionadas con los ficheros,: información sobre nombre, atributos, directorios, etc.

File(String directorioyfichero): new File(“C:\\directorio\\fichero.txt”)File fichero1 = new File(“C:\\EJERCICIOS\\UNI1\\ejemplo1.txt”);

File(String directorio, String nombrefichero): new File(“directorio”, “fichero.txt”)String directorio= “C:\\EJERCICIOS\\UNI1”;File fichero2 = new File(directorio, “ejemplo2.txt”);

Ejemplo. Muestra la lista de ficheros del directorio actual

import java io.*;public class VerDir { public static void main(String[] args) { System.out.println(“Ficheros en el directorio actual:”); File f = new File(“.”); - - - - - - - - -- - -- - - -- - - - - File f = new

File(“d:\\db”); String[] archivos = f.list(); for (int i = 0; i < archivos.lenght; i++) { System.out.println(archivos[i]); } }}

1.2 Clases asociadas a las operaciones de gestión de ficheros

Esto mostraría la lista de ficheros del directorio d:\db

getName()

getPath()

getAbsolutePath()

canRead()

canWrite()


length()

createNewFile()

delete()

exists()

getParent()

isDirectory()

isFile()

mkDir()

renameTo(File nuevonombre)

Algunos de los métodos más importantes de la clase File son los siguientes:

import java io.*;

public class VerInf {

public static void main(String[] args) {

System.out.println(“Infromación sobre el fichero:”);

File f = new File(“VerInf.java”);

if (f.exists(){

System.out.println(“Nombre del fichero: “+f.getName());

System.out.println(“Ruta : “+f.getPath());

System.out.println(“Se puede escribir : “+f.canWrite());

System.out.println(“Tamaño : “+f.length());

System.out.println(“Es un directorio : “+f.isDirectory());

System.out.println(“Es un fichero : “+f.isFile());

}

}

}


Ejemplo. Mostrar información sobre el fichero VerInfo.java:

import java io.*;public class CreaDir { public static void main(String[] args) { File d = new File(“NUEVODIR”); d.mkdir(); File f1 = new File(d, “Fichero1.txt”); File f2 = new File(d, “Fichero2.txt”); try { if (f1.createNewfile()) System.out.println(“Fichero1 creado correctamente”); else System.out.println(“No se puede crear Fichero1.txt”); if (f2.createNewfile()) System.out.println(“Fichero2 creado correctamente”); else System.out.println(“No se ha puede crear

Fichero2.txt”); }catch (IOException ioe) {ioe.printStackTrace();} f1.renameTo(new File(d, “Fichero1Nuevo.txt”)); }}

1.2 Clases asociadas a las operaciones de gestión de ficherosEjemplo. Crear un nuevo directorio con dos ficheros vacíos y renombrar uno de ellos.

El paquete java.io contiene muchas clases que implementan el sistema de entrada/salida.

La abstracción del flujo (stream) trata la comunicación de datos entre una fuente y destino: disco duro, memoria, sitio de red, etc.

Cualquier programa que requiera enviar/recibir datos de otra fuente necesita abrir un stream.

La vinculación del stream al dispositivo físico la hace el sistema de entrada/salida de Java.

Tipos de flujos al sistema de entrada/salida:

Flujo de bytes (8 bits). Operaciones de E/S de bytes; orientado la L/E de datos binarios. Clases InputStream y OutputStream. Cada una de estas clases tiene subclases que controlan las diferencias entre los distintos dispositivos de E/S que se pueden utilizar.

Flujo de caracteres (16 bits). Operaciones de E/S de caracteres. Clases Reader y Writer.

1.3 Flujos o streams. Tipos

1.3.1 Flujos de bytes (Byte streams)

La clase InputStream representa las clases que producen entradas de fuentes tales como un array de bytes, un objeto String, un fichero, etc. Los tipos de InputStream son:


•ByteArrayInputStream

•StringBufferInputStream

•FileInputStream.

•PidedInputStream.

•FilterInputStream.

•SequenceInputStream.

La clase OutputStream incluye las clases que deciden donde irá la salida: un array de bytes, un fichero o una “tubería”. Los tipos de InputStream son:•ByteArrayOutputStream

•FileOutputStream.

•PidedOutputStream.

•FilterOutputStream.

1.3.2. Flujos de caracteres (Character streams) Las clases Reader y Writer manejan flujos de caracteres Unicode. Hay

situaciones en que hay que usar clases que manejan bytes combinadas con clases que utilizan caracteres.

En esos casos se utilizan clases “puente” que convierten los streams de bytes a streams de caracteres.

InputStreanReader convierte un InputStream en un Reader y OutputStreamReader convierte un OutputStream en un Writer.


Clases de flujos de bytes

•InputStream

•OutputStream

•FileInputStream

•FileOutputStream

•StringBufferInputStream

•(sin clase correspondinte)

•ByteArrayInputStream

•ByteArrayOutputStream

•PidedInputStream

•PidedOutputStream

Clase correspondiente de flujo de caracteres

ReaderWriter

FileReader

FileWriter

Stringreader

Stringwriter

CharArrayReader

CharArrayWriter

PidedReader

PidedWriter

Las clases de flujos de caracteres más importantes son:

FileReader y FilerWriter lectura y escritura de caracteres en ficheros.

CharArrayReader y CharArrayWriter para leer y escribir un flujo de caracteres en un array de caracteres.

BufferedReader y BufferedWriter para evitar que cada operación de lectura o escritura acceda directamente al fichero.


1.4 Formas de acceso a un fichero Acceso secuencial. Los datos se leen y escriben en el mismo orden en

que están almacenados. Para acceder al registro N hay que acceder primero a los (N-1) anteriores.

Acceso directo o aleatorio. Permite acceder a un registro en cualquier orden sin necesidad de leer los anteriores.

El acceso secuencial en ficheros más común en Java puede ser binario o de caracteres.

Operaciones básicas sobre un fichero sea cual asea su forma de acceso:

Creación del fichero.

Apertura del fichero.

Cierre del fichero.

Lectura de los datos del fichero.

Escritura de datos en el fichero.

Operaciones sobre un fichero una vez abierto:

Altas.

Bajas. El borrado consiste en reescribir.

Modificaciones.

Consultas.

1.5 Operaciones sobre ficheros Flujos o streams. Tipos

1.5.2. Operaciones sobre ficheros secuenciales

Altas. Se realizan al final del último registro insertado.

Bajas. Hay que leer y escribir en un fichero auxiliar todos los registros excepto el que se quiere borrar. Después borrar el fichero original y renombrar el auxiliar con el nombre del original.

Modificaciones. Proceso similar al de las bajas.

Consultas. Para consultar el registro N, hay que leer los (N-1) registros anteriores.

Los ficheros secuenciales se utilizan en:

Procesos por lotes.

Copias de respaldo (backup).

Ventajas. Rápido acceso al registro siguiente y aprovechamiento del espacio en disco.

Desventajas. Lectura de pocos registros y las actualizaciones.

1.5 Operaciones sobre ficheros Flujos o streams. Tipos

1.6.1. Ficheros de texto

Utilizaremos la clase FileReader para leer caracteres y FileWriter para escribir caracteres en un fichero.

Al trabajar con operaciones de L/E en ficheros se hará dentro de un manejador de excepciones try-catch.

Métodos de la clase FileReader para lectura.

int read()

int read(char[] buf)

int read(char[] buf, int desplazamiento, int n))

Para crear o abrir un fichero en Java, se invoca a la clase File y se crea el flujo de entrada hacia el fichero con la clase FileReader. Después se realizan las operaciones de L/E y se cierra el fichero con el método close().

1.6 Clases para gestión de flujos de datos desde/hacia ficheros


Ejemplo: Programa que lee los caracteres de un fichero de texto y los muestra por pantalla.

import java.io.*;

public class LeeFichTexto {

public static void main (String[] args) throws IOException {

//declarar fichero

File fichero = new File(“C:\\Micarpeta\\LeerFichTexto.java”);

FileReader fic = new FileReader(fichero); // crear el flujo de entrada

int i;

while ((i = fic.read()) != -1) // se va leyendo un carácter

System.out.println((char) i);

fic.close(); // cerrar fichero

}

}



Los métodos que proporciona la clase FileWriter para escritura son: void write(int c) void write(char[] buf) Escribe un array de caracteres void write(char[] buf, int desplazamiento, int n) void write(String str) append(char c)

El siguiente ejemplo escribe caracteres en un fichero de nombre FichTexto.txt

(si no lo crea). Los caracteres se obtienen uno a uno y se obtienen de un String.

import java.io.*;public class EscribirFichTexto { public static void main (String[] args) throw IOExceptions { File fichero = new File(“C:\\Micarpeta\\FichTexto.txt”); FileWriter fic = new FileWriter(fichero); // crear el flujo de

salida String cadena = “Esto es una prueba de FileWriter”; char{[] cad = cadena.toCharArray(); //convierte un String a un

array de caracteres. for (int i=0; i<cad.length; i++) fic.write(cad[i]); //se va escribiendo un carácter fic.append(‘*’); //añadimos al final un * fic.close(); // cerramos el fichero }}



Ejemplo String pueblo[] = {“Catarroja”, “Albal”, “Silla”, “Masanassa”, “Benetusser”};

for (int i=0; i<pueblo.lenght; i++) fic.write(pueblo[i]);

FileReader no contiene métodos para leer líneas completas. BufferedReader si.

Ejemplo: Lee un fichero de texto por la línea y visualizarlo por pantalla.import java.io.*;public class LeerFichTextoBuf { public static void main (String[] args) throw IOExceptions { try BufferReader fichero = new BuffereReader (new

FileReader(“LeerFichTexto.java”)); String linea; while(linea=fichero.readLine())|=null) // lee una línea del

fichero System.out.println(linea); fichero.close(); } catch (FileNotFoundException fn) { System.out.println(l”No se

encuentra el fichero”);} catch (IOException io) { System.out.println(l”Error de E/S”);}}



La clase PrintWriter que también deriva de Writer, posee los métodos print(String) y println(String) para escribir en un fichero.

Para construir un PrintWriter necesitamos la clase FileWriter

PrintWriter fichero = new PrintWriter(new Writer(NomFich))

El ejemplo anterior utilizando la clase PrintWriter y el método println() quedaría:

PrintWriter fichero = new PrintWriter(new FileWriter(NomFich))

for (int i=1; 1<11; i++)

fichero.println(“Fila número: “+i);

fichero.close();


1.6.2. Ficheros binarios

Se trata de ficheros que almacenan secuencias de dígitos binarios que no son legibles por el usuario. Ocupan menos espacio en disco. Las clases de Java que trabajan con ficheros binarios son FileInputStream y FileOutputStream.

Métodos de la clase FileInputStream.

int read() Lee un byte y lo devuelve

int read(byte[] b) Lee hasta b.lenght bytes de datos de una matriz de bytes

int read(byte[] b, int desplazamiento, int n) lee hasta n bytes de la matriz b comenzando por b[desplazamiento] y devuelve el número de bytes leídos.

Métodos de la clase FileOutputStream.

void write(int b)

void write(byte[] b)

void write(byte[] b, int desplazamiento, int n)


1.6.2. Ficheros binarios

El siguiente ejemplo escribe bytes en un fichero y después los visualiza.import java.io.*;public class EscribeFichBytes { public static void main (String[] args) throw IOExceptions { File fichero = new File(“C:\MiCarpeta\\FcihBytes.dat”); //crea flujo de salida hacia elf ichero FileOutputStream fileout = new FileOutputStream(fichero); //crea flujo de entrada FileInputStream filein= new FileInputStream(fichero); int i;

for (i=1; i<100; i++) fileout.write(i); //escribe datos en el flujo de salida fileout.close(); // cerrar stream de salida

//visualizar los datos del fichero while ((i=filein.read()) != -1) //lee dato del flujo de entrada System.out.println(i); filein.close(); //cerrar stream de entrada }}


Objetos serializables

¿Cómo guardamos un objeto de tipo empleado con atributos (dni, nombre, tfno,...)?

Java permite guardar objetos en fichero binarios. Para eso el objeto debe implementar la interfaz serializable que dispone de una serie de métodos con los que podremos guardar y leer objetos en ficheros binarios:

void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFound Exception: para leer un objeto.

void writeObject(java.io.ObjectOutputStream stream) throws IOException, ClassNotFound Exception: para escribir un objeto.

La serialización de objetos de Java permite tomar cualquier objeto que implemente la interfaz Serializable y convertirlo en una secuencia de bits.

Para leer/escribir objetos serializables a un stream se utilizan las clases Java ObjectInputStream y ObjectOutputStream.



Ejemplo: Clase Persona que implementa la interfaz Serializable y que utilizaremos para escribir y leer objetos en un fichero binario.

import java.io.Serializable;

public class Persona implements Serializable { private String nombre; private int edad;

public Persona (String nombre, int edad) { this.nombre=nombre; this.edad=edad; } public Persona() { this.nombre=null; } public void setNombre(String nom) {nombre=nom} public void setEdad(int ed) {edad=nom;}

public String getNombre() {return nombre;} //devuelve nombre public int getEdad() {return edad;} //devuelve edad

} //fin persona



Ejemplo: Escribir objetos Persona en un fichero

import java.io;

public class EscribirFichObject { public static void main (String[] args) throws IOException { Persona persona; //defino variable persona //declaro el fichero File fichero = new File(“C:\\MiCarpeta\\FichPersona.dat”); FileOutputStream fileout = new FileOutputStream (fichero); //salida //conecta el flujo de bytes al flujo de datos ObjectOutputStream datOS = new ObjectOutputStream(fileout);

String nombres[] = {“Pepe”, “Juan”, “Ana”, “Eva”, Luis”}; int edades[] = {18, 20, 19, 20, 18};

for (int i=0; i<edades.length; i++) { //recorro los arrays persona = new Persona(nombres[i], edades[i]); //creo la persona datOS.writeObject(persona); //escribo la persona en el fichero } datOS.close(); //cerrar stream de salida } }



Ejemplo: Leer objetos Persona de un fichero

import java.io;

public class LeerFichObject { public static void main (String[] args) throws IOException,

ClassNotFoundException { Persona persona; //defino variable persona File fichero = new File(“C:\\MiCarpeta\\FichPersona.dat”); FileInputStream filein = new FileInputStream (fichero); //entrada //conecta el flujo de bytes al flujo de datos ObjectInputStream datIS = new ObjectInputStream(filein);

try { while (true) { //lectura del fichero persona = (Persona) dataqIS.readObject(); //leer una persona System.out.println(“Nombre: “ + persona.getNombre() + “, edad: “

+ persona.getEdad()); } }catch (EOFException eo) {} datIS.close(); //cerrar stream de entrada } }


1.6.3. Ficheros de acceso aleatorio

La clase de Java RandomAccessFile dispone de métodos para acceder a ficheros binarios de manera aleatoria.

Hay dos formas de crear ficheros de acceso aleatorio:

Escribiendo el nombre del fichero

fichero = new RandomAccessFile(String nombre, String modoAcceso);

Con un objeto File

fichero = new RandomAccessFile(File fich, String modoAcceso);

El argumento modoAcceso puede ser r para lectura o rw para lectura-escritura

Una vez abierto el fichero utilizaremos los métodos read() y write() de las clases DataInputStream y DataOutpuStream para leer y escribir

Otros métodos importantes:

long getFilePointer() long length()

void seek(long posicion) int skipBytes(int desplazamiento)




import java.io.*;

public class EscribirFichAleatorio { public static void main (String[] args) throws IOException { File fichero = new File(“C:\\MiCarpeta\\AleatorioEmple.dat”); RandomAccessFile file = new RandomAccessFile(fichero, “rw”); //arrays con los datos Si donde ponemos “rw” es escritura String nombre[] = {“Pepe”, “Juan”, “Ana”, “Eva”, Luis”}; int dep[] = {10, 20, 10, 10, 30}; Double salario[]={1000, 1200, 1300, 1000, 1200}; StringBuffer buffer = null //buffer para almacenar nombre int n=nombre.length // nº de elementos del array for (int i=0; i<n; i++) { //recorro los arrays file.writeInt(i+1);/ // buffer=new StringBuffer(nombre[i]); buffer.setLength(10);// 10 caracteres para el nombre file.writeInt(dep[i]); file.writeDouble(salario[i]); } file.close(); //cerrar fichero }}



import java.io;

public class LeerFichAleatorio { public static void main (String[] args) throws IOException { File fichero = new File(“C:\\MiCarpeta\\AleatorioEmple.dat”);RandomAccessFile file = new RandomAccessFile(fichero, “r”); int id, dep, posicion;Double salario;

char nombre[] = new char[10], aux for (;;){ //recorro el fichero con un bucle mientras qeuden datos en el fichero. file.seek(posicion); id=file.readInt(); for (int i=0; i<nombre.length;i++ { aux=file.readChar()//recorre uno de los caract. del nombre nombre[i]=aux; } String nombreS=new String(nombre)//convierto a String el array dep=file.readInt(); salario=file.readDouble() Sistem.out.println(“ID: “ + id +”, nombre: “+ nombreS + “, Departamento: “:+dep + “, salario: “ + salario); posicion= posicion + 36 // me posiciono el el sig. Empleado ya que cada uno utiliza 36 bytes

} file.close(); //cerrar fichero }}



Sistem.out.println(“ID: “ + id +”, nombre: “+ nombreS + “, Departamento: “:+dep + “, salario: “ + salario); posicion= posicion + 36 // me posiciono el el sig. Empleado ya que cada uno utiliza 36 bytes (4 + 20 + 4 + 8)//Si he recorrido todos los bytes salgo del forif (file.getFilePointer()==file.legth()) break;} //del del bucle forfile.close(); //cerrar fichero }}

Qué es XML...

Metalenguaje para definir lenguajes de marcado.

Fichero de texto; información organizada secuencialmente y en orden jerárquico.

Jerarquía de la información y contenidos dentro del propio documento.

Un fichero XML se utiliza para...

Proporcionar datos a una BD o almacenar copias de partes de la BD.

Escribir ficheros de configuración de programas o en el protocolo SOAP, para ejecutar comandos en servidores remotos.

El contenido de un fichero XML se lee con un parser. Los más utilizados son DOM (Modelo de Objetos de Documento) y SAX (API simple para XML). Son independientes del lenguaje de programación y existen versiones para Java, Visual Basic, C,...

1.7 Trabajo con fichero XML

DOM

Almacena toda la estructura del documento en memoria en forma de árbol. Requiere más memoria si los ficheros XML son grandes y complejos.

SAX

Lee el fichero XML de forma secuencial y genera una secuencia de eventos en función de los resultados de la lectura. Cada evento invoca un método definido por el programador. Consume menos memoria.


1.7.1. Acceso a ficheros XML con DOM

Para trabajar con DOM en Java necesitamos el paquete org.w3c.dom y el paquete java.xml.parsers del API estándar de Java.

Las clases de java.xml.parsers ofrecen métodos para cargar documentos desde una fuente de datos (fichero, InpuStream,..). Destacan dos clases: DocumentBuilderFactory y DocumentBuilder.

Para generar un fichero XML a partir de un árbol DOM necesitamos el paquete java.xml.transform, que permite especificar una fuente y un resultado.

La fuente y el resultado pueden ser ficheros, flujos de datos o nodos DOM.


1.7.1. Acceso a ficheros XML con DOM

Interfaces que necesitan los programas Java que utilicen DOM:

Document. Objeto que equivale a un ejemplar de un documento XML.

Element. Expone propiedades y métodos para manipular los elementos del documento y sus atributos.

Node. Representa a cualquier nodo del documento.

NodeList. Contiene una lista con los nodos hijos d un nodo.

Attr. Permite acceder a los atributos de un nodo.

Text. Son los datos carácter de un elemento.

CharacterData. Proporciona atributos y métodos para manipular los datos de caracteres.

DocumentType. Proporciona información contenida en la etiqueta <!DOCTYPE>.

Ejemplo pág. 26.


1.7.2. Acceso a ficheros XML con SAX

SAX (API Simple para XML) es un conjunto de clases e interfaces que ofrecen una herramienta muy útil para el procesamiento de documentos XML.

Permite analizar los documentos de forma secuencial (bajo consumo de memoria).

Es un API escrito en Java, incluido dentro de JRE. Esto permite crear un parser de XML propio.

La lectura de un documento XML produce eventos que ocasionan la llamada a métodos : startDocument(), endDocument(), starElement() endElement(), (characters()), etc.

En el ejemplo la clase se llama GestionContenido y se tratan los eventos básicos. (págs. 31-33)

startDocument: se produce al comenzar el procesado del documento XML.endDocument: se produce al finalizar el procesado del documento XML. startElement: se produce al comenzar el procesado de una etiqueta XML. endElement: se produce al finalizar el procesado de una etiqueta XML. characters: se produce al encontrar una cadena de texto.



A continuación hay que indicar al XMLReader qué objetos poseen los métodos que tratarán los eventos: Esos objetos serán implementaciones de las siguientes interfaces:

ContentHandler: recibe notificaciones de los eventos que ocurren en el documento.

DTDHandler. Recoge eventos relacionados con la DTD.

ErrorHandler: define métodos de tratamiento de errores.

EntityResolver: sus métodos se llaman cada vez que se encuentra una referencia a una entidad.

DefaultHandler: clase que provee una implementación por defecto para todos sus métodos. De esta clase se harán las extensiones para crear el parser de XML.


import org.xml.sax.Attributes;import org.xml.sax.InputSource;import org.xml.sax.SaxExceptions;import org.xml.sax.XMLReader;import org.xml.sax.DefaultHandler;import org.xml.sax.XMLReaderFactory;

Clases en interfaces de SAX para hacer que se puedan tratar los eventos.


public class PruebaSax1 {

public static void main (String[] args)

throws FileNotFoundException, IOException, SAXException {

XMLReader procesadorXML = XMLReaderFactory.createXMLReader();

GestionContenido gestor = new GestionContenido();

procesadorXML.setContentHandler(gestor);

InputSource fileXML = new InputSource(“alumnos.xml”);

procesadorXML.parse(fileXML);

}

}// fin pruebaSax1


1.7.2. Acceso a ficheros XML con SAXclass GestionContenido extends DefaultHandler { public GestionContenido() {super();} public void startDocument(){

System.out.println(“Comienzo del documento XML”); } public void endDocument(){

System.out.println(“Fin del documento XML”); } public void startElement(String uri, String nombre, String nombreC,

Attributes atts){System.out.println(“\tFin Elemento: “ + nombre);

} public void endElement(String uri, String nombre, String nombreC){

System.out.println(“tFin Elemento: “ + nombre); } public void characters(char[] ch, int inicio, int longitud) throws

SAXException {String car = new String(ch, inicio, longitud);car = car.replaceAll(“[\t\n]”,””); //quitar saltos de líneaSystem.out.println(“\tCaracteres: “ + car);

}}// fin GestionContenido


1.7.3. Serialización de objetos a XML

Veremos como serializar objetos Java a XML y viceversa utilizando la librería Xstream.Hay que descargar los JAR de www.xstream.codehaus.org/download.html. En este caso, el fichero xtream-distribution-1.4.2-bin.zip de donde hay que buscar el JAR xstream-1.4.2.jar que está en la carpeta lib. También necesitamos el archivo kxml2-2.3.0.jar que se puede descargar desde el apartado Optional Dependencies.

Hay que definir los dos ficheros en el CLASSPATH.

Partiendo de FichPersona.dat, crearemos una lista de objetos Persona y la convertiremos en un fichero de datos XML.import java.util.ArrayList; import java.util.List;public class ListaPersonas { private List<Persona> lista = new ArrayList<Persona>(); private ListaPersonas() { } public void add(Persona per) {

lista.add(per); } public List>Persona> getListaPersonas() {

return lista; }}


http://www.xstream.codehaus.org/download.html

1.7.4. Conversión de ficheros XML a otro formatoMediante el lenguaje Java se puede generar un fichero HTML a partir de un fichero XML que contiene datos y otro XSL que contiene la presentación de esos datos.import org.w3c.dom.*;import javax.xml.parsers.*;import javax.xml.transform.*;import javax.xml.transform.dom.*; import javax.xml.transform.dom.*;import javax.io.*;publica class convertidor {public static void main (String argv[]) throws IOException { String hojaEstilo = “alumnosPlantilla.xsl”; String datosAlumnos = “alumnos.xml”; File pagHTML = new File(“mipagina.html”) FileOutputStream os = new FileOutputStream(pagHTML); Source estilos = new StreamSource(hojaEstilo); // fuente XSL Source datos = new StreamSource(datosAlumnos); // fuente XML Result result = new StreamResult(os);try {Transformer transformer =

TransformerFactory.newInstance().newTransformer(estilos);transformer.transform(datos, result); } //obtiene el HTMLcatch (Exception e) {System.err.println(“Error: “+e);}os.close();}}


Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias.

Cuando no es capturada por el programa, se captura por el gestor de excepciones por defecto que retorna un mensaje y detiene el programa.

Cuando se produce un error por una excepción dentro de un método Java, el método crea un objeto Exception.

El manejo de excepciones en Java está pensado para situaciones en las que el método que detecta un error no es capaz de manejarlo.

Las excepciones en Java son objetos de clases derivadas de la clase base Exception que a su vez es una clase derivada de la clase Throwable.

1.8 Excepciones: Detección y Tratamiento

1.8.1. Capturar excepciones

Para capturar una excepción se utiliza el bloque try-catch. Se encierra en un bloque try el código que puede generar una excepción; este bloque va seguido por uno o más bloques catch.Cada bloque catch especifica el tipo de excepción que puede atrapar y contiene un manejador de excepciones .Después del último bloque catch puede aparecer un bloque finally, que siempre se ejecuta haya ocurrido o no una excepción.

try { //Código que puede generar excepciones} catch (excepcion1 e1) { //manejo de la excepción1} //Código que puede generar excepciones} catch (excepcion1 e2) { //manejo de la excepción2}// etc...finally { // Se ejecuta después de try o catch}


1.8.2. Especificar excepciones

Para especificar excepciones utilizamos throws, seguida de la lista de los tipos de excepciones potenciales.Si un método decide no gestionar una excepción (mediante try-catch), debe especificar que puede lanzar esa excepción.

public static void main(String[] args) throws Oexception, ClassNotFoundException {

En la línea anterior, el método main() puede lanzar las excepciones IOException y ClassNotFoundException.


Unidad 1. Manejo de ficheros 1.1. Introducción. 1.2. Clases asociadas a las operaciones de gestión...

Documents

Transcript of Unidad 1. Manejo de ficheros 1.1. Introducción. 1.2. Clases asociadas a las operaciones de gestión...