unidad 4: lenguaje de programación orientado a objetos

Programación II JAVA AVANZADO DR. MARIO ROSSAINZ LÓPEZ

UNIDAD 4: Lenguaje de Programación Orientado A Objetos, Elementos Avanzados

4.1. Tratamiento de Excepciones

Java incorpora soporte para manejar situaciones anómalas que pueden ocurrir durante la

ejecución de un programa, a través de las excepciones. Una excepción proporciona una

manera limpia y controlada de verificar errores. El manejo de excepciones ofrece una

forma de separar el código que maneja los errores, del código base de una aplicación. Por

ejemplo:

try{ // código de la aplicación } catch(tipo_excepcion e) { // Código de tratamiento de la excepcion } catch (tipo_excepcion e) { // Código de tratamiento de la excepcion }

Las excepciones en Java son objetos de clases derivadas de la clase Throwable definida

dentro del paquete java.lang.


Existen excepciones implícitas que son aquellas que lanza la JVM y los métodos

implementados en las aplicaciones no estan obligados a manejarlas. Por ej.,

RuntimeExcepcion.

Y las excepciones explícitas donde si se quieren utilizar y manipular, los métodos

implementados en las aplicaciones tienen que declararlas, lanzarlas y tratarlas. Por ej.,

IOException.

Cuando un método se encuentra con una anomalía que no puede resolver, éste lanza

(throw) una excepción, esperando que quien lo llamó, directa o indirectamente la capture

(catch) y maneje la anomalía. Incluso él mismo podría capturar y manipular dicha

excepción. Si la excepción no se captura, el programa finaliza de forma anormal. En este

ejemplo, se genera una excepción que no es atendida


4.1.1. Generación de Excepciones

Cualquier método puede lanzar excepciones en Java. Se tendrían entonces que declarar

todas las posibles excepciones que se puedan generar en dicho método. Para ello se

utiliza la claúsula throws en la declaración del método. Para lanzar una excepción se crea

un objeto de tipo Exception o alguna de sus subclases, como por ejemplo

ArithmeticException y se lanza mediante la instrucción throw.

4.1.2. Captura de Excepciones

Cuando se lanza una excepción el sistema es responsable de encontrar a alguien que la

capture para manipularla. Un manejador de excepciones es una porción de código que se

encarga de tratar las posibles excepciones que se puedan generar. Se estructuran con tres

bloques: Try-catch-finally.

El bloque try: Para que un método sea capaz de tratar una excepción generada por la

JVM, habrá que encerrar las instrucciones que la podrían generar dentro de un bloque try.

El bloque catch: Cualquier excepción producida dentro de try será analizado por los

bloques catch que se tengan. Cada bloque try debe tener asociado cuando menos un

bloque catch capaz de tratar un tipo de excepción


El bloque finally: Se utiliza para ejecutar un bloque de instrucciones sea cual sea la

excepción que se produzca. Éste bloque se ejecutará en cualquier caso incluso sin que se

produzca excepción alguna.


4.1.3. Creación de Excepciones

Se pueden crear y definir excepciones propias en Java. Habrá que heredar de la clase

Exception e implementar la funcionalidad extra que se requiera en el tratamiento de esa

excepción.

Todos los métodos Java utilizan la sentencia throw para lanzar una excepción. El sig.

ejemplo muestra la función pop() cuyo propósito es sacar el elemento superior de una pila

de datos.


Para crear una clase de tipo throwable, habrá que hacerla heredar de una clase de tipo

Exception o subclases de ella y definir el constructor con un mensaje de entrada.


4.2. Interfaces Gráficas de Usuario

Las aplicaciones en JAVA que se comunican con el usuario final a través de Interfaces

gráficas son de tres tipos:

1. FRAMES: Son aplicaciones locales en JAVA que se ejecutan a través del método

main(…) en las cuales podemos incluir componentes que integran una interfaz gráfica

para comunicarse con el usuario final.

2. APPLETS: Son aplicaciones en JAVA (que no tienen un método main(…)) que se llaman

dentro de una página WEB para su ejecución, en las cuales podemos incluir

componentes que integran una interfaz gráfica para comunicarse con el usuario.

3. APLICACIONES JAVA PARA REDES E INTERNET:

Páginas Servidoras de JAVA o JSP

Scripts de JAVA o JavaScript

Programas Servidores de Aplicaciones (Servlets)

Programación Distribuida en red con Sockets

Componentes Reutilizables (JavaBeans)

Acceso a bases de datos usando JDBC

El diseño de interfaces gráficas de usuario en estos tres tipos de aplicaciones en JAVA se

logra incorporando componentes gráficos definidos en la biblioteca de clases denominada

JFC-Java -Foundation-Clases que actualmente agrupa las siguientes APIs (Aplication

Programming Interfaces – Interfaz de Programación de Aplicaciones):

Swing: Conjunto de componentes escritos en JAVA para diseñar interfaces gráficas de

usuario que se ejecutan uniformemente en cualquier plataforma nativa que soporta la

máquina virtual de JAVA.

AWT (Abstract Window Toolkit): Es el kit de herramientas de ventanas abstractas de

JAVA y proporciona un conjunto de componentes para diseñar interfaces gráficas de

usuario común a todas las plataformas nativas.

Accesibilidad

Java 2D

Una Interfaz Gráfica de Usuario o GUI se forma mínimamente de una ventana y a partir de

ella se pueden añadir componentes Swing o AWT necesarios. Este proceso consiste en

crear dichos componentes y colocarlos en el contenedor incorporado en la propia ventana


o en otros contenedores que se pueden crear de forma explícita. La colocación (posición)

de los componentes en un contenedor esta supeditada a un administrador de diseño que

podremos utilizar.

4.2.1. COMPONENTES:

Los nombres de los componentes de Swing y AWT difieren en que los primeros se escriben

anteponiendo la letra “J” a su nombre. Es decir, lo que para AWT es un Button, para Swing

será JButton.

Los componentes más comunes tanto en Swing como en AWT son:

Etiquetas (para AWT Label y para Swing JLabel)

Botones (para AWT Button y para Swing JButton)

Cajas de texto (TextField o JTextField para una línea de texto y TextArea o JTextArea

para varias líneas de texto)

Casillas de verificación (para AWT CheckBox y para Swing JCheckBox)

Botones de Opción (para AWT RadioButton y para Swing JRadioButton)

Listas (Para AWT List y para Swing JList)

Barras de Desplazamiento (ScrollBar para AWT y JScrollBar para Swing)

Cuadros de diálogo (JOptionPane para Swing y OptionPane para AWT)

4.2.2. CONTENEDORES:

Son componentes Swing utilizados para ubicar otros componentes. Una ventana es un

contenedor y dentro de ello podemos añadir componentes como los listados

anteriormente o bien otros contenedores mediante una jerarquía. La raíz de esa jerarquía

siempre será la ventana y en este nivel encontramos a JFrame, JDialog, JApplet.

Cada contenedor define un componente contenedor llamado “Panel”. Una ventana ya sea

JFrame, JDialog o JApplet define un panel raíz a través del cual se establece una jerarquía

de más paneles o componentes. Para acceder al panel raíz de una ventana ésta debe

invocar al método getContentPane.

En general un Panel que no sea el raíz será un panel de contenido intermedio creado a

través de JPanel, cuyo propósito es simplificar la colocación de componentes o bien de

otros páneles.


Los componentes se añaden a un panel usando el método add(…) del objeto panel.

MiFrame miFrame= MiFrame(); miFrame.getContentPane.add(miPanel); JPanel miPanel=new JPanel(); miPanel.add(miBoton); impanel.add(miEtiqueta);

4.2.3. ADMINISTRADORES DE DISEÑO:

Un administrador de diseño se utiliza para mostrar varios componentes a la vez en un

determinado orden. Por default cada contenedor tiene asignado un administrador de

diseño.

Swing proporciona 6 administradores de diseño:

BorderLayout: Divide el contenedor en cinco secciones, norte, sur, este, oeste y centro.

Es el administrador de diseño por default de los contenedores de nivel superior. Los

compomenetes se colocarán en una sección u otra según decidamos.

GridLayout: Es un diseño en forma de rejilla, es decir, coloca los compomentes en el

contenedor ordenados por filas y columnas.

GridBagLayout: Diseño tipo rejilla. Igual que GridLayout solamente que además

permite que un componente pueda ocupar más de una fila y/o columna.

CardLayout: Administrador que permite colocar en el contenedor grupos diferentes de

compomentes en instants diferentes de la ejecución. Se diseña por medio de paneles.

BoxLayout: Coloca los componentes en e contenedor en una única fila o columna,

ajustándose al espacio que haya.

FlowLayout: Coloca los componentes en el contenedor de izquierda a derecha. Es el

administrador de diseño por default de los contenedores de nivel intermedio.

Además de estos se puede utilizar el administrador de diseño absoluto o no utilizar

ninguno (administrador de diseño nulo). Con ellos se pueden colocar los componentes

exactamente donde se quiera, o bien utilizar el diseño libre (diseñador por omisión).

Cuando se quiera Asignar a un contenedor un administrador de diseño diferente al

predeterminado, primero hay que crearlo y después asignárselo usando setLayout. Por

ejemplo, la siguiente instrucción asigna al contenedor miPanel un administrador de diseño

de tipo GridLayout con cero filas y una columna:

MiPanel.setLayout(new GridLayout(0,1));


La siguiente instrucción indica que no se asignará ningún administrador de diseño al

contenedor del objeto referenciado por this:

getContentPane().setLayout(null);

El siguiente código es una aplicación que muestra una ventana principal con un botón y

una etiqueta. En ella se observa que el botón se activa o bien dando clic en él o bien

pulsando la combinación de teclas “Alt+c” y tiene asociada una breve descripción. Sin

embargo, la aplicación no hace nada, es decir, no responde al clic que hace el usuario

sobre el botón.

import javax.swing.*; //componentes GUIs public class CAplicacion3 extends JFrame { private JLabel etiSaludo; private JButton botonSaludo; public CAplicacion3() // constructor { setSize(300, 200); // tamaño de la ventana del frame setTitle("Aplicación"); // título de la ventana del frame initComponents(); // iniciar los controles o componentes } private void initComponents() { etiSaludo=new JLabel(); botonSaludo=new JButton(); getContentPane().setLayout(null); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // ATRIBUTOS DE LA ETIQUETA etiSaludo.setText("Hola Mundo"); etiSaludo.setHorizontalAlignment(SwingConstants.CENTER); etiSaludo.setFont(new java.awt.Font(java.awt.Font.SERIF,java.awt.Font.ITALIC,25)); getContentPane().add(etiSaludo); etiSaludo.setBounds(42,36,204,50); botonSaludo.setText("ACEPTAR"); botonSaludo.setToolTipText("De clic aqui o pulse ALT+c"); botonSaludo.setMnemonic('c'); getContentPane().add(botonSaludo); botonSaludo.setBounds(42,90,204,30); } public static void main(String args[]) { CAplicacion3 miFrame= new CAplicacion3(); miFrame.setVisible(true); System.out.println("Hola Mundo!!!"); } }


4.2.4. MANEJO DE EVENTOS:

Un evento es la ejecución de una acción por parte del usuario sobre algún componente de

la GUI de la aplicación. Los eventos que se producen sobre un componente se manipulan a

través de objetos denominados manejadores o escuchadores de eventos.

Un componente tendrá asociados tantos escuchadores de eventos como tipos de eventos

tenga que manejar.

Java proporciona varios manejadores de eventos, cada uno de los cuales maneja un tipo

particular de eventos, por ejemplo:

WindowListener permite a una ventana responder a las acciones que ocurren sobre

ella que serán eventos de tipo WindowEvent

ActionListener permite a un componente responder a las acciones que ocurren sobre

él que serán eventos de tipo ActionEvent, como por ejemplo dar clic sobre un botón.

Para vincular un manejador de eventos a un componente se crea una clase que

implemente la interfaz que aporta los métodos que permite responder al tipo de eventos

Componente Escuchador Evento Ocurrido

Método (Respuesta al evento)


que tratamos de manejar. Suponiendo que queremos vincular un manejador de eventos a

un botón, entonces deberíamos de implementar la interfaz ActionListener.

public class ManejaEvtMiBoton implements java.awt.event.ActionListener { public void actionPerformed(java.awt.event.ActionEvent evt) { // responder al evento evt } } Public class MiFrame extends javax.swing.JFrame { ... . . . main() { . . . //manejador de eventos de Miboton Java.awt.event.ActionListener al= new ManejaEvtMiBoton(); // vinculo del manejador de eventos con el boton miBoton miBoton.addActionListener(al); . . . } }

O bien utilizar una clase anónima, es decir, una clase implícita dentro del código de otra

clase explícita:

public class MiFrame extends javax.swing.JFrame { ... . . . main() { java.awt.event.ActionListener al= new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { // responder al evento evt } }; miBoton.addActionListener(al); . . . } }

El argumento evt de actionPerformed en el código anterior no es más que un objeto-

evento que proporciona información tal como:


El componente que originó el evento

Si se pulsó simultáneamente alguna(s) tecla(s)

El tipo de evento

La orden asociada con ese evento

Etc.

Por ejemplo, si hubiera más de un componente asociado con el manejador de eventos

anterior, deberíamos proceder como sigue:

public class MiFrame extends javax.swing.JFrame { ... . . . main() { java.awt.event.ActionListener al= new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { Object obj=evt.getSource>(); //objeto que produjo el evento if (obj==MiBoton) { //responder al evento } if (obj==MiEtiqueta) { //responder al evento } . . . } }; miBoton.addActionListener(al); miEtiqueta.addActionListener(al); . . . } }

O bien proceder en función de la clase del componente:

public class MiFrame extends javax.swing.JFrame { ... . . . main() { java.awt.event.ActionListener al= new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { Object obj=evt.getSource>(); //objeto que produjo el evento


if (obj instanceOf java.x.swing.JButton) { //responder al evento } if (obj== instanceOf java.x.swing.JLabel) { //responder al evento } . . . } }; miBoton.addActionListener(al); miEtiqueta.addActionListener(al); . . . } }

4.2.5. ADAPTADORES:

La interfaz ActionListener proporciona un solo método, pero WindowListener (para el

manejo de los eventos de ventanas) proporciona varios. Suponiendo que necesitáramos

añadir al manejador de Eventos WindowListener para controlar la acción de cerrar la

ventana. Al proceder de la misma forma que lo hicimos para actionListener el siguiente

código no compilaría:

public class MiFrame extends javax.swing.JFrame { ... . . . main() { java.awt.event.WindowListener al= new java.awt.event.WindowListener() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } . . . }; this.addWindowListener(al); . . . } }

Recuerde que cuando se implementa una interfaz, debe uno redefinir todos y cada uno de

sus métodos abstractos que tiene para que pueda compilar. Por tanto, si quisiéramos


utilizar sólo el método windowClosing y no los demás, la implementación la deberíamos

hacer de la siguiente manera:

public class MiFrame extends javax.swing.JFrame { ... . . . main() { java.awt.event.WindowListener al= new java.awt.event.WindowListener() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } public void windowOpened(java.awt.event.WindowEvent evt){;} public void windowClosed(java.awt.event.WindowEvent evt){;} public void windowIconified(java.awt.event.WindowEvent evt){;} public void windowDeiconified(java.awt.event.WindowEvent evt){;} public void windowActivated(java.awt.event.WindowEvent evt){;} public void windowDeactivated(java.awt.event.WindowEvent evt){;} . . . }; this.addWindowListener(al); . . . } }

La solución para no sobreescribir todos los métodos abstractos de WindowListener y sólo

los que se quieran ocupar está en la clase adaptadora WindowAdapter contenida en

java.awt.event. Esta clase implementa la interfaz WindowListener definiendo todos sus

métodos vacíos. Con esto el manejador de eventos del tipo WindowListener lo

escribiríamos así:

public class MiFrame extends javax.swing.JFrame { ... . . . main() { java.awt.event.WindowListener al= new java.awt.event.WindowAdapter() { public void windowClosing(java.awt.event.WindowEvent evt) { exitForm(evt); } . . . }; this.addWindowListener(al); . . .


} }

El paquete java.awt.event define adaptadores para todas las interfaces que proporcionan

más de un método como: FocusAdapter, KeyAdapter, MouseAdapter, etc.

4.2.6. RESPONDER A EVENTOS:

Cuando ya se tiene el diseño de la GUI en la aplicación el último paso es dotarla de

funcionalidad, es decir, que en respuesta a los eventos que se realizan sobre los

componentes de la GUI, la aplicación responda con una acción determinada.

En el anterior ejemplo (escrito en la sección administradores de diseño de éste

documento), dotaremos al botón de funcionalidad de forma que cuando el usuario de clic

sobre él o pulse ALT+c, aparezca la etiqueta “Hola Mundo”, con un color distinto

(aleatorio) en cada pulsación.

public class CAplicacion extends javax.swing.JFrame { private javax.swing.JButton jBtSaludo; private javax.swing.JLabel jEtSaludo; public CAplicacion() { setSize(300, 200); // tamaño del formulario setTitle("Aplicación"); // título del formulario initComponents(); // iniciar los controles o componentes } private void initComponents() { jEtSaludo = new javax.swing.JLabel(); jBtSaludo = new javax.swing.JButton(); getContentPane().setLayout(null); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); jEtSaludo.setFont(new java.awt.Font("Dialog", 1, 18)); jEtSaludo.setHorizontalAlignment(javax.swing.SwingConstants.CENTER); jEtSaludo.setText("etiqueta"); getContentPane().add(jEtSaludo); jEtSaludo.setBounds(42, 36, 204, 30);


jBtSaludo.setMnemonic('c'); jBtSaludo.setText("Haga clic aquí"); jBtSaludo.setToolTipText("botón de pulsación"); jBtSaludo.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jBtSaludoActionPerformed(evt); } }); getContentPane().add(jBtSaludo); jBtSaludo.setBounds(42, 90, 204, 30); } private void jBtSaludoActionPerformed (java.awt.event.ActionEvent evt) { float rojo = (float)Math.random(); float verde = (float)Math.random(); float azul = (float)Math.random(); jEtSaludo.setForeground(new java.awt.Color(rojo, verde, azul)); jEtSaludo.setText("¡¡¡Hola mundo!!!"); } private void exitForm(java.awt.event.WindowEvent evt) { System.exit(0); } public static void main(String args[]) { new CAplicacion().setVisible(true); } }


4.2.7. APPLETS

Un Applet se define como un pequeño programa diseñado para ser ejecutado dentro de

una página WEB Un applet se diferencia de una aplicación JAVA en que éste último se

carga y se ejecuta desde cualquier explorador que soporte JAVA.

4.2.8. CREACIÓN DE UN APPLET:

Sólo se necesita escribir una clase que herede de Applet o de JApplet:

public class MiApplet extends java.applet.Applet { // Este es el applet más simple que se puede construir }

O bien:

public class MiApplet extends javax.swing.JApplet { // Este es el applet más simple que se puede construir }

Una vez creado el programa éste se compila para obtener el archivo MiApplet.class el cual

deberá ser llamado dentro del código HTML de una página WEB utilizando el tag <applet

…> </applet>

<html> <head …> <title> . . . </title> </head>


<body> <applet code=MiApplet.class width=350 height=200> </applet> . . . </body> </html>

Los métodos más importantes de los applets son:

init(): Llamado una sola vez cuando se carga el applet. Se utiliza para inicializarlo. Es el

equivalente a los constructores en las aplicaciones de JAVA que no son applets.

start(): Éste método es llamado después de que se ejecute init() y cada vez que el

applet se vuelve a visitar en una página WEB.

paint(): método heredado por la clase Applet de la clase Container. Es llamado cada

vez que es necesario repintar el contenedor del applet o área de dibujo.

stop(): es llamado para informar al applet que su ejecución es detenida. Esto ocurre

siempre que la página que muestra el applet es reemplazada por otra página, y justo

antes de que sea destruido.

destroy(): Es invocado después de stop() para informar al applet de que va a ser

destruido, con el fin de que pueda liberar cualquier recurso que tenga asignado.

Por cuestiones de seguridad y dado que el applet se ejecuta del lado del cliente cuando se

accede a una página WEB que lo contiene a través de internet, éste no puede hacer lo

siguiente:

Leer o escribir archivos

Leer propiedades del sistema operativo

Comunicarse con un sitio de internet distinto al que sirvió la página web donde esta

contenido ese applet

Ejecutar un programa

Cargar bibliotecas o definir métodos nativos

Un ejemplo simple: El applet HolaMundo:

import java.awt.*; import javax.swing.*; /* <applet code="HolaMundo.class" width=300 height=50> </applet> */


public class HolaMundo extends JApplet { public void init() { getContentPane().setLayout(new FlowLayout()); JLabel eti1=new JLabel("Hola MUndo!!!"); JLabel eti2=new JLabel("Como estas?"); getContentPane().add(eti1); getContentPane().add(eti2); } }

4.3. FLUJOS DE ENTRADA/SALIDA

Uno de los paquetes más importantes de JAVA es el paquete io que contiene el sistema de

E/S básico del lenguaje incluyendo la E/S con archivos.

Los programas JAVA realizan la entrada/salida a través de flujos (streams). Un flujo es una

abstracción que produce o consume información y esta relacionado con un dispositivo

físico a través del sistema de entrada y salida de JAVA.

Todos los flujos se comportan de la misma manera, incluso aunque estén relacionados con

distintos tispositivos físicos. Por esta razón se pueden aplicar las mismas clases y métodos

de E/S a cualquier tipo de dispositivo.


Un flujo de entrada puede abstraer distintos tipos de entrada, ya sea desde un disco hasta un teclado o una conexión de red. De la misma forma un destino de salida puede ser una consola, un archivo de disco o una conexión de red.

4.3.1. CLASES DE FLUJOS

JAVA implementa los flujos dentro de una jerarquía de clases definida en el paquete io.java. En la parte superior de la jerarquía hay dos clases abstractas InputStream y OutputStream. JAVA tiene algunas subclases concretas de cada una de ellas para gestionar las diferencias que existen entre los distintos dispositivos, como archivos de disco, buferes de memoria, etc. Las clases abstractas InputStream y OutputStream definen algunos métodos que las otras clases implementan como son el método read() y write() que respectivamente leen y escriben bytes de datos.

4.3.2. FLUJOS PREDEFINIDOS

Todos los programas JAVA importan el paquete java.lang. Este paquete define una clase

llamada System que encapsula aspectos del entorno de ejecución. Además contiene tres

variables con flujos predefinidos llamadas in, out y err. Estos campos estan declarados

como public y static en System por lo cual se pueden utilizar en cualquier parte del

programa sin tener una referencia a un objeto System específico.

System.out se refiere al flujo de salida estándar (por default es la consola). System.in hace referencia a la entrada estándar (que por defecto es el teclado). System.err se refiere al flujo de error estándar (que por defecto también es la consola).

4.3.3. ENTRADA POR CONSOLA En JAVA la entrada por consola se efectúa leyendo bytes de un flujo de entrada. Estos bytes se pueden leer en varios objetos como pueden ser caracteres y cadenas.

Read():

El método de entrada de más bajo nivel es read() y tiene distintas formas. El formato más

común que se utiliza es:

int read() throws IOException


Cada vez que se llama a read() lee un único byte del flujo de entrada y lo devuelve como

un valor entero. El método devuelve –1 cuando encuentra el final del flujo de entrada.

Puede generar una excepcíon del tipo IOException.

El siguiente programa muestra el funcionamiento de read() donde lee caracteres de la

entrada estándar hasta que el usuario pulsa la letra “q”.

// Ejemplo del método read()

import java.io.*;

class UseRead

{

public static void main(String args[])

throws IOException

{

char c;

System.out.println(“Introduzca caracteres;

‘q’ para salir...”);

// lee caracteres

do {

c= (char) System.in.read();

System.out.println(c);

}while (c!=’q’);

}

}

Un ejemplo de ejecución es el siguiente:

Introduzca caracteres, ‘q’ para salir...

123abcq

1

2

3

a

b

c

q

System.in es por defecto un flujo con buffer. Esto significa que realmente no se pasa

ninguna entrada al programa hasta que se pulsa <enter>. Ahora bien, los flujos de entrada

y salida estándares pueden ser redirigidos. El siguiente programa muestra cualquier


archivo de texto en pantalla, suponiendo que la entrada estandar ha sido redirigida al

archivo deseado cuando comienza el programa. Esto hace que System.in utilice dicho

archivo como entrada.

/*

Muestra un archivo de texto.

Para utilizar este programa es necesario redirigir la

entrada al archivo que se quiere mostrar. Por ejemplo,

para mostrar un archivo llamada prueba.txt se utiliza la

siguiente orden:

Java ShowFile < prueba.txt

*/

import java.io.*;

class ShowFile

{


throws IOException

{

int i;

// lee caacteres hasta llegar al final del archivo (EOF)

do {

i= System.in.read();

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

}while (i!=-1);

}

}

Lectura de una cadena:

JAVA proporciona un método llamado readLine() que automáticamente lee una secuencia

de caracteres de un flujo de entrada y devuelve un objeto del tipo String. Este método

forma parte de la clase DataInputStream que proporciona métodos para leer todos los

tipos simples de JAVA, además de lineas de texto. La forma general de readLine es la

siguiente:

Final String readLine() throws IOException


Este método devuelve un objeto String. Antes de utilizar el método readLine() es

necesario obtener un objeto DataInputStream asociado al flujo de entrada. Para hacer

esto se utiliza el constructor:

DataInputStream( InputStream flujo_de_entrada)

Donde flujo_de_entrada es el flujo que se asocia a la instancia de DataInputStream que se

va a crear. Para leer la entrada por consola se puede utilizar como parámetro System.in. El

siguiente programa lee e imprime líneas de texto hasta que se introduzca la palabra “fin”.

// Ejemplo del método readLine()

import java.io;

class ReadLines

{


throws IOException

{

// Crea un InputDataStream utilizando System.in

DataInputStream inData= new DataInputStream(System.in);

String str;

System.out.println(“INTRODUZCA LINEAS DE TEXTO”);

System.out.println(“Introduzca fin para finalizar...”);

do {

str= inData.readLine();

System.out.println(str);

}while(!str.equals(“fin”));

}

}

El siguiente ejemplo crea un pequeño editor de texto. Crea una matriz de objetos String y

después lee líneas de texto almacenándolas en la matriz. El programa finaliza cuando haya

leído 100 líneas o cuando lea la palabra “fin”.

// Un pequeño editor

import java.io.*;

class TinyEdit

{


throws IOException

{


// Crea un InputDataStream utilizando System.in

DataInputStream inData= DataInputStream(System.in);

String str[]= new String[100];

System.out.println(“Introduzca lineas de texto”);

System.out.println(“Introduzca ‘fin’ para finalizar”);

for (int i=0; i<100; i++)

{

str[i]= inData.readLine();

if (str[i].equals(“fin”))

break;

}

System.out.println(“Este fue el texto que introduciste...”);

for (int i=0; i<100; i++)

{

if (str[i].equals(“fin”))

break;

System.out.println(str[i]);

}

}

}

4.3.4. SALIDA POR CONSOLA

La salida por consola se realiza con la ayuda de los métodos print() y println() que ya se

han utilizado anteriormente. Estos métodos están definidos en la clase PrintStream, que

es el tipo del objeto referenciado por System.out. Además, PrintStream es un flujo de

salida derivado de OutputStream y también implementa el método de bajo nivel write().

La forma más simple de usar éste método definida en PrintStream es:

Void write(int valor_byte)

Este método escribe el valor especificado por valor_byte. El siguiente programa utiliza el

método write() para imprimir el carácter “A” seguido de un carácter de línea nueva “\n”.

// Ejemplo de System.out.write()

class WriteDemo

{


{

int b;


b=’A’;

System.out.write(b);

System.out.write(“\n”);

}

}

Normalmente no se suele utilizar el método write() para presentar información en la

consola.

4.3.5. FLUJOS DE ARCHIVO

Las clases FileInputStream y FileOutputStream crean flujos asociados a archivos. Para

abrir un archivo, es necesario crear un objeto de una de estas clases, especificando el

nombre del archivo como argumento del constructor.

FileInputStream(String archivo) throws FileNotFoundException FileOutputStream(String archivo) throws IOException

Aquí, archivo especifica el nombre del archivo que se desea abrir. Cuando se crea un flujo

de entrada, si el archivo no existe se genera una excepción FileNotFoundException. Para

los flujos de salida, si no se puede crear el archivo se genera una excepción IOException.

Cuando se abre un archivo de salida se destruye cualquier archivo existente que tuviese el

mismo nombre.

Cuando se ha terminado de trabajar con un archivo, es necesario cerrarlo utilizando el

método close(). Este método esta definido tanto en FileInputStream como en

FileOutputStream.

void close() throws IOException

Para leer un archivo se puede utilizar el método read() con la siguiente sintaxis definida en

FileInputStream

int read() throws IOException

Cada vez que se llama a este método lee un único byte del archivo y lo devuelve como un

valor entero. Cuando encuentra el final del archivo devuelve –1. El siguiente programa


utiliza el método read() para leer y mostrar el contenido de un archivo de texto cuyo

nombre se pasa como argumento en línea de comandos..

/*

Muestra un archivo de texto.

Para utilizar este programa, especifique

el nombre del archivo que desea ver.

por ejemplo, para ver un archivo llamado PRUEBA.TXT

se utiliza la siguiente orden java ShowFile PRUEBA.TXT

*/

import java.io.*;

class ShowFile

{


throws IOException

{

int i;

FileInputStream fin;

try {

fin= new FileInputStream(args[0]);

}catch(FileNotFoundException e) {

System.out.println(“Archivo no encontrado...”);

Return;

}catch(ArrayIndexOutOfBoundsException e) {

System.out.println(“Formato: ShowFile archivo”);

return;

}

// lee caracteres hasta llegar al final del archivo (EOF)

do {

i= fin.read();

if (i != -1)

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

}while (i != -1);

fin.close();

}

}

Para escribir en un archivo se puede utilizar el método write() definido en

FileOutputStream

void write(int valorByte) throws IOException

El siguiente programa utiliza el método write() para copiar un archivo de texto.

/*

Copia un archivo de texto...

Para utilizar este programa, especifique

el nombre de los archivos origen y destino.

Por ejemplo, para copiar un archivo llamado ORIGEN.TXT,


en un archivo llamado DESTINO.TXT,

se utiliza la siguiente orden. Java CopyFile ORIGEN.TXT

DESTINO.TXT

*/

import java.io.*;

class CopyFile

{


throws IOException

{

int i;

FileInputStream fin;

FileOutputStream fout;

try{

fin= new FileInputStream(args[0]);

fout= new FileOutputStream(args[1]);

}catch(FileNotFoundException e) {

System.out.println(“Archivo no encontrado”);

return;

}catch(IOException e){

System.out.println(“Error al abrir el archivo de salida”);

return;

}catch(ArrayIndexOutOfBoundsException e){

System.out.println(“Formato: CopyFile Origen Destino”);

}

try {

do {

i= fin.read();

if (i != -1) fout.write(i);

}while(i != -1);

}catch(IOException e) {

System.out.println(“Error...”);

}

fin.close();

fout.close();

}

}

4.3.6. FILE:

La clase File trabaja directamente con los archivos y no sobre flujos. Es decir, la clase File

no especifica como se recupera o almacena la información la información en los archivos;

sólo describe las propiedades de un objeto archivo.

Un objeto File se utiliza para obtener o modificar la información asociada con un archivo de disco, como los permisos, hora, fecha y directorio y para navegar por la jerarquía de

subdirectorios


Como File no trabaja con flujos, no es una subclase de InputStream o OutputStream. Un

directorio en JAVA se trata igual que un archivo con una propiedad adicional: una lista de

nombres de archivo que se pueden examinar utilizando el método list(). Los objetos File

se pueden crear utilizando uno de los siguientes tres constructores disponibles:

File(String directorio) File(String directorio, String nom_arch) File(File obj_Dir, String nom_arch)

El parámetro directorio es el nombre del directorio, nom_arch es el nombre del archivo y

obj_Dir es un objeto File que especifica un directorio. El siguiente ejemplo crea tres

archivos: f1, f2, f3. El primer objeto File se construye utilizando un directorio como único

argumento. El segundo se crea utilizando dos argumentos: el directorio y el nombre del

archivo. El tercero se crea utilizando el directorio asignado a f1 y un nombre de archivo; f3

hace referencia al mismo archivo que f2.

File f1= new File(“/”);

File f2= new File(“/”,”autoexec.bat”);

File f3= new File(f1,”autoexec.bat”);

La clase File define muchos métodos para determinar las propiedades de un objeto File:

El método getName() devuelve el nombre de un archivo.

El método getParent() devuelve el nombre del directorio padre.

El método exist() devuelve true si el archivo existe y false en caso contrario.

Sin embargo hay muchos métodos dentro de File con los que podemos examinar las

propiedades del objeto, pero no se proporcionan las funciones correspondientes para

cambiar sus atributos. El siguiente ejemplo muestra alguno de los métodos de File.

// Ejemplo de la clase File

import java.io.File;

class FileDemo

{

static void p(String s)

{

System.out.println(s);

}

public static void main(String args[]) {


File f1= new File(“/java/COPYRIGTH”);

p(“Archivo: “+f1.getName());

p(“Directorio: “+f1.getPath());

p(“Directorio Absoluto: “+f1.getAbsolutePath());

p(“Padre: “+f1.getParent());

p(f1.exists()? “existe” : “no existe”);

p(f1.canWrite() ? “se puede escribir” :

“no se puede escribir”);

p(f1.canRead() ? “se puede leer” : “no se puede leer”);

p((f1.isDirectory() ? “ ” : “no”)+”es un directorio”);

p(f1.isFile() ? “es un archivo normal” :

“podría ser un enlace con nombre”);

p( “última modificacion: ” + f1.lastModified());

p(“tamaño del archivo: “+ f1.length() + “Bytes”);

}

}

La ejecución de este programa sería algo parecido a:

Archivo: COPYRIGHT

Directorio: /java/COPYRIGHT

Directorio Absoluto: /java/COPYRIGHT

Padre: /java

Existe

Se puede escribir

Se puede leer

No es un directorio

Es un archivo normal

Ultima modificación: 812465204000

Tamaño del archivo: 695 Bytes

La clase File también incluye métodos específicos cuyo uso esta restringido al trabajo con

archivos convencionales, esto es, no pueden ser llamados sobre directorios. Algunos de

estos son:

renameTo(): boolean renameTo(File nuevo_nombre)

donde el nombre del archivo especificado por nuevo_nombre es el nuevo nombre del

archivo. Devolverá true si se realiza con éxito y false en caso contrario.

delete(): boolean delete()

cuyo propósito es eliminar el archivo de disco representado por el trayecto del objeto File.

Este método solo funciona sobre objetos que son archivos simples. Devuelve true si

elimina el archivo y false en caso contrario.


4.3.7. DIRECTORIOS:

Un directorio es un File que contiene una lista de otros archivos y directorios. Cuando se

crea un objeto File y es un directorio, el método isDirectory() devolverá true. En este caso,

se puede llamar al método list() sobre ese objeto para extraer la lista de los otros archivos

y directorios que contiene. Una de las formas de uso del método list() es:

String[ ] list()

La lista de archivos se devuelve en una matriz de objetos del tipo String. El siguiente

programa muestra como examinar el contenido de un directorio utilizando el método

list(). Si se llama al método list() sobre un objeto File que no sea un directorio se provoca

una excepción del tipo: NullPointerException (excepción de apuntador nulo) en tiempo de

ejecución.

// Uso de directorios

import java.io.File;

class DirList

{


{

String dirname= “/java”;

File f1=new File(dirname);

if (f1.isDirectory())

{

System.out.println(“Directorio de “+dirname);

String s[]=f1.list();

for (int i=0; i< s.length; i++)

{

File f= new File(dirname+”/”+s[i]);

if (f.isDirectory())

{

System.out.println(s[i]+ “ es un directorio”);

}

else {

System.out.println(s[i]+ “es un archivo”);

}

}

}

else {

System.out.println(dirname+ “ no es un directorio”);

}

}


}

FilenameFilter:

A menudo se desea limitar el número de archivos devuelto por el método list() para que

se incluyan únicamente aquellos archivos cuyo nombre cumpla con cierto patrón o filtro.

Para hacer esto se utiliza la segunda forma de uso del método list():

String list(FilenameFilter objFF)

En esta forma, el parámetro objFF es un objeto de una clase que implementa la interfaz

FilenameFilter. Esta interfaz define un único método accept() al que se llama una vez por

cada archivo de la lista. Su forma general es:

Boolean accept(File directorio, String nom_archivo)

Este método devuelve true para los archivos del directorio que deberían ser incluidos en

la lista. Es decir, aquellos que coincidan con el argumento nom_archivo y false para

aquellos que deberían ser excluidos.

La siguiente clase mostrada a continuación como ejemplo, implementa la interfaz

FilenameFilter. Esta clase restringe la visibilidad de los nombres de archivo devueltos por

el método list(). La restricción se aplica a los archivos cuyos nombres terminan con la

extensión que se pasa como parámetro en su constructor.

import java.io.*;

public class OnlyExt implements FilenameFilter

{

String ext;

public OnlyExt(String ext)

{

this.ext=”.”+ext;

}

public boolean accept(File dir, String name)


{

return name.endsWith(ext);

}

}

A continuación se muestra el programa que presenta el directorio, de manera que liste

sólo los archivos que tienen extensión .html.

// directorio de archivos .html

import java.io.*;

class DirListOnly

{


{

String dirname=”/java”;

File f1= new File(dirname);

FilenameFilter only= new OnlyExt(“html”);

String s[]= f1.list(only);

for (int i=0; i<s.length; i++)

{

System.out.println(s[i]);

}

}

}

File tiene otros métodos específicos para trabajar con directorios:

El método mkdir() crea un directorio, devolviendo true si tiene éxito la creación y false en

caso contrario.

Si se quiere crear un directorio cuando el path no existe, hay que utilizar el método

mkdirs() el cual no sólo creará un directorio sino que además creará todos los padres de

éste.

NOTA: Se pueden crear directorios utilizando un objeto File, pero sin embargo no se

pueden eliminar.

4.3.8. LAS CLASES STREAM:

Anteriormente se dio una introducción a la E/S de JAVA basada en flujos la cual se

desarrolla a partir de dos clases abstractas: InputStream y OutputStream. Estas clases

definen una funcionalidad básica común a todas las clases de flujo.

InputStream:


Es una clase abstracta que define el modelo de JAVA para el flujo de entrada. Todos sus

métodos lanzarán una exscepción IOException si se producen errores. Los métodos de

esta clase son:

METODO DESCRIPCION

int read()

Devuelve un entero como

representación del siguiente byte

disponible en la entrada

int read(byte bufer[])

Intenta leer hasta bufer.length bytes

situándolos en bufer y devuelve el

número real de bytes leidos con éxito

int read(byte bufer[], int off,

int len)

Intenta leer hasta len bytes situándolos

en bufer comenzando en bufer[off] y

devuelve el número de bytes leidos con

éxito

int skip(long num)

Omite num bytes de la entrada y

devuelve el número de bytes que se

han omitido.

int available() Devuelve el número de bytes

disponibles actualmente para su lectura

void close() Cierra el origen de entrada

void mark(int num)

Coloca una marca en el punto actual

del flujo de entrada que seguirá siendo

válida hasta que se lean num bytes.

void reset() Devuelve el apuntador de entrada a la

marca establecida nuevamente.

boolean markSupported() Devuelve true si se admiten los

métodos mark() o reset() en este flujo.

OutputStream Es una clase abstracta que define el flujo de salida. Todos los métodos de esta clase

devuelven un valor void y lanzan una IOException en caso de error.La siguiente tabla

muestra los métodos definidos por esta clase:


METODO DESCRIPCION

void write(int b) Escribe un único byte en un flujo de

salida.

void write(byte bufer[]) Escribe una matriz completa de bytes

en un flujo de salida.

void write(byte bufer[], int

off, int len)

Escribe len bytes de la matriz bufer,

comenzando a partir de bufer[off].

void flush()

Inicializa el estado de la salida de

manera que se limpian todos los

buferes.

void close() Cierra el flujo de salida.

FileInputStream:

Esta clase crea un InputStream que se puede utilizar para leer el contenido de un archivo.

Sus constructores más comunes son:

FileInputStream(String directorio) FileInputStream(File objArch)

Estos constructores lanzan una FileNotFoundException en caso de error. El parámetro

directorio es el nombre completo del directorio de un archivo y objArch es un objeto File

que describe el archivo. Por ejemplo:

FileInputStream f0= new FileInputStream(“/autoexec.bat”);

File f= new File(“/autoexec.bat”);

FileInputStream f1= new FileInputStream(f);

FileInputStream sobrescribe seis de los métodos de la clase abstracta InputStream. Los

métodos mark() y reset() no sesobrescriben y cualquier intento de utilizar estos métodos

en un FileInputStream generará una IOException.

El siguiente ejemplo muestra cómo leer un único byte, una matriz de bytes y una parte de

una matriz de bytes. También muestra como saber cuántos bytes quedan utilizando

available() y como omitir los bytes no deseados utilizando el método skip(). El programa

lee su propio archivo origen que debe estar en el directorio actual.


// Ejemplo de FileInputStream

import java.io.*;

class FileInputStreamDemo

{

public static void main(String args[]) throws Exception

{

int size;

InputStream f=new FileInputStream(“FileInputStreamDemo.java”),

System.out.println(“Bytes totales disponibles: “

+(size=f.available()));

int n=size/40;

System.out.println(“Los primeros “+n+

” bytes del archivo se leen en una operación read()”);

for (int i=0; i<n; i++)

{

System.out.print((char)f.read());

}

System.out.println(“\n Total disponible todavía: “+

f.available());

System.out.println(“leyendo los siguientes: “+n+

“ bytes con una llamada a read(b[])”);

byte b[]= new byte[n];

if (f.read(b) != n)

{

System.err.println(“No se puede leer “+n+” bytes”);

}

System.out.println(new String(b,0,0,n));

System.out.println(“\n total disponible: “+

(size=f.available()));

System.out.println(“Omite la mitad de los bytes restantes

Con skip()”);

f.skip(size/2);

System.out.println(“\n total disponible: “+f.available());

System.out.println(“leyendo “+n/2+” bytes del final de la

matriz”);

if (f.read(b,n/2,n/2) != n/2)

{

System.err.println(“No se pueden leer “+n/2+” bytes”);

}

System.out.println(new String(b,0,0,b.length));

System.out.println(\n total disponible: “+f.available());

f.close();

}

}


FileOutputStream Crea un OutputStream que se puede utilizar para escribir en un archivo. Sus constructores

más comunes son:

FileOutputStream(String directorio) FileOutputStream(File objArch)

Los dos constructores pueden lanzar una IOException o una SecurityException en caso de

error. El parámetro directorio es el nombre completo del directorio de un archivo y

objArch es un objeto File que describe el archivo.Si se intenta abrir un archivo de sólo

lectura como un FileOutputStream se lanzará una IOException.

El siguiente ejemplo crea un bufer de bytes creando en primer lugar una cadena y después

usa el método getBytes() para obtener la matriz de bytes equivalente. Después se crean

tres archivos. file1.txt que contiene los bytes pares, file2.txt que contiene el conjunto

completo de bytes, y file3.txt que contiene la última cuarta parte del bufer.

//ejemplo de FileOutputStream

import java.io.*;

class FileOutputStreamDemo

{

public static void main(String args[]) throws Exception

{

String source=”Ahora es el momento de que los hombres buenos\n”

+” vengan a ayudar a su país\n”

+” y paguen sus impuestos”;

byte buf[]= new byte[source.length()];

source.getBytes(0,buf.length,buf,0);

OutputStream f0= new FileOutputStream(“file.txt”);

for (int i=0; i<buf.length;i+=2)

{

f0.write(buf[i]);

}

f0.close();

OutputStream f1= new FileOutputStream(“file2.txt”);

f1.write(buf);

f1.close();

OutputStream f2= new FileOutputStream(“file3.txt”);

f2.write(buf,buf.length-buf.length/4,buf.length/4);

f2.close();

}

}


RandomAccessFile:

Esta clase encapsula un archivo de acceso aleatorio y no es derivada de InputStream ni de

OutputStream, sino que implementa las interfaces DataInput y DataOutput que definen

los métodos de entrada y salida básicos. También permite peticiones de posicionamiento,

es decir, se puede situar el puntero dentro del archivo. Esta clase tiene dos constructores:

RandomAccessFile(File objArch, String acceso) RandomAccessFile(String nomArch, String acceso)

En el primer constructor, objArch especifica el nombre del archivo que se desea abrir

como objeto File. En el segundo constructor, el nombre del archivo se pasa en nomArch.

En ambos casos, acceso determina el tipo de acceso al archivo que se permite. Si es “r”,

entonces sólo se puede leer el archivo y no se puede escribir en él. Si es “rw”, entonces el

archivo se abre en modo lectura-escritura. El método seek() se utiliza para establecer la

posición actual del puntero dentro del archivo.

Void seek(long posicion)

Aquí, posición especifica la nueva posición en bytes, del puntero desde el inicio del

archivo. Después de llamar a seek(), la siguiente operación de lectura o escritura se

realizará en la nueva posición dentro del archivo. RandomAccessFile implementa los

métodos de entrada y salida estándar que se pueden utilizar para leer y escribir en

archivos de acceso aleatorio.

4.3.9. Seriación de objetos La seriación en Java se utiliza para escribir y leer objetos a y desde un archivo. Es decir, es

la operación mediante la cual se envía una serie de objetos a un archivo para hacerlos

persistentes. El proceso contrario de recuperar el estado de la serie de objetos del archivo

para reconstruirlos en memoria recibe el nombre de “deseriación”. El paquete java.io

proporciona las clases ObjectOutputStream y ObjectInputStream para realizar

operaciones de seriación y deseriación de forma automática.


Para hacer la seriación de los objetos de una clase se debe implementar la interfaz

Serializable, la cual es una interfaz vacía que no tiene métodos y que tiene como propósito

identificar aquellas clases cuyos objetos pueden ser seriados. Por ejemplo, el siguiente

código muestra la definición de una clase cuyos objetos pueden ser seriados.

import java.io.*;

public class Persona implements Serializable

{

// Cuerpo de la clase…

}

4.3.9.1. Escritura de objetos en un archivo

Utilizaremos un objeto de tipo ObjectOutputStream para enviar un flujo de datos de tipos

primitivos y objetos a un flujo OutputStream, concretamente a un objeto

FileOutputStream puesto que lo que se quiere es almacenar objetos en un archivo.

Posteriormente esos objetos podrán ser reconstruidos a través de un objeto de tipo

ObjectInputStream.

Para escribir un objeto dentro de un objeto ObjectOutputStream, utilizaremos el método

writeObject de dicha clase. Éste método lanzará una excepción de tipo

NotSerializableException si se intenta escribir un objeto de una clase que no implementa

la interfaz Serializable. El siguiente código construye un ObjetoOutputStream sobre un

FileOutputStream y lo utiliza para almacenar una cadena y un objetoPersona en un

archivo llamado datos.

FileOutputStream fos=new FileOutputStream(“datos”);

ObjectOutputStream oos=new ObjectOutputStream(fos);

oos.writeUTD(“Archivo datos”);

oos.write(new Persona(nombre, dirección, teléfono));

oos.close();

Como ejemplo, se muestra una clase llamada Directorio que permita almacenar objetos

de tipo Persona en un archivo de nombre “directorio.dat”.

Programa Persona.java

import java.io.*;

public class Persona implements Serializable

{

String nombre;

int edad;


long telefono;

public Persona(String nombre, int edad,

long telefono)

{

this.nombre=nombre;

this.edad=edad;

this.telefono=telefono;

}

public String toString()

{

return "Nombre: "+nombre+" Edad: "+edad+

" anios Telefono: "+telefono;

}

}

Programa Directorio.java

import java.io.*;

import java.util.*;

public class Directorio

{

public static void creaArchDir(String nomarch)

throws IOException

{

Scanner inDatos=new Scanner(System.in);

String resp="";

String nombre;

int edad;

long tel;

FileOutputStream out;

out=new FileOutputStream(nomarch);

ObjectOutputStream f;

f=new ObjectOutputStream(out);

do{

System.out.print("\nNombre: ");

nombre=inDatos.next();

System.out.print("\nEdad: ");

edad=inDatos.nextInt();

System.out.print("\nTelefono: ");

tel=inDatos.nextLong();

f.writeObject(new Persona(nombre,

edad,tel));

System.out.print("\nContinuar (S/N: ");

resp=inDatos.next();

}while (resp.equals("S"));

}



{

try{

creaArchDir("directorio.dat");

}catch(IOException e){ ; }

}

}

4.3.9.2. Lectura de objetos desde un archivo

Un objeto de la clase ObjectInputStream permite recuperar datos de tipos primitivos y

objetos desde un objeto InputStream. De forma concreta, cuando se trate de datos de

tipos primitivos y objetos almacenados en un archivo, utilizaremos un objeto

FileInputStream.

Para leer un objeto desde un flujo ObjectInputStream se deberá utilizar el método

readObject. Si se almacenaron objetos y datos de tipos primitivos, éstos deberán ser

recuperados en el mismo orden. El siguiente código crea la aplicación MuestraDir que lee

los objetos del archivo y muestra su información en pantalla.

Programa MuestraDir.java

import java.io.*;

public class MuestraDir

{

public static void muestraArchDir(String

nomarch)throws IOException

{

Persona p;

String resp="";

String nombre;

int edad;

long tel;

FileInputStream in;

in=new FileInputStream(nomarch);

ObjectInputStream f;

f=new ObjectInputStream(in);

try{

do{

p=(Persona)f.readObject();

System.out.println(p);

}while(true);

}catch(EOFException e){

;

}catch(ClassNotFoundException e){;}

}



{

try{

muestraArchDir("directorio.dat");

}catch(IOException e){;}

}

}

unidad 4: lenguaje de programación orientado a objetos

Documents