Está en la página 1de 25
PROGRAMACIÓN ORIENTADA A OBJETOS CON JAVA CAPÍTULO 6: UTILIDADES JAVA 1
PROGRAMACIÓN ORIENTADA A OBJETOS CON JAVA CAPÍTULO 6: UTILIDADES JAVA 1

PROGRAMACIÓN ORIENTADA A OBJETOS

CON JAVA

CAPÍTULO 6:

UTILIDADES JAVA

CONTENIDOS T EMA 6: Utilidades Java. 1. I/O EN JAVA 2. SERIALIZACIÓN DE OBJETOS 3. ORDENACIÓN

CONTENIDOS

TEMA 6: Utilidades Java.

  • 1. I/O EN JAVA

CONTENIDOS T EMA 6: Utilidades Java. 1. I/O EN JAVA 2. SERIALIZACIÓN DE OBJETOS 3. ORDENACIÓN
  • 2. SERIALIZACIÓN DE OBJETOS

  • 3. ORDENACIÓN DE OBJETOS

  • 4. TIPOS DE OBJETOS EN COLECCIONES

  • 5. DOCUMENTACIÓN DE PROGRAMAS EN JAVA

I/O EN JAVA • Normalmente las aplicaciones necesitan leer o escribir información desde o hacia una

I/O EN JAVA

I/O EN JAVA • Normalmente las aplicaciones necesitan leer o escribir información desde o hacia una

Normalmente las aplicaciones necesitan leer o escribir información desde o hacia una fuente externa de datos.

La información puede estar en cualquier parte, en un fichero, en disco, en algún lugar de la red, en memoria o en otro programa.

También puede ser de cualquier tipo: objetos, caracteres, imágenes o sonidos.

La comunicación entre el origen de cierta información y el

destino

se

realiza

mediante

un

stream

(flujo)

de

información. Un stream es

un

objeto que hace de

intermediario entre el programa y el origen o destino de la

información.

I/O EN JAVA • Para traer la información, un programa abre un stream sobre una fuente
I/O EN JAVA • Para traer la información, un programa abre un stream sobre una fuente

I/O EN JAVA

Para traer la información, un programa abre un stream sobre una fuente de información (un fichero, memoria, un socket) y lee la información, de esta forma:

I/O EN JAVA • Para traer la información, un programa abre un stream sobre una fuente

De igual forma, un programa puede enviar información a un destino externo abriendo un stream sobre un destino y escribiendo la información en este, de esta forma:

I/O EN JAVA • Para traer la información, un programa abre un stream sobre una fuente

Los algoritmos para leer y escribir:

abrir un stream mientras haya información leer o escribir información

cerrar el stream

El paquete java.io contiene una colección de clases stream que soportan estos algoritmos para leer y escribir. Estas clases están divididas en dos árboles basándose en los tipos de datos (caracteres o bytes) sobre los que opera.

4

I/O EN JAVA • Streams de Caracteres: – Reader y Writer son las superclases abstractas para

I/O EN JAVA

Streams de Caracteres:

I/O EN JAVA • Streams de Caracteres: – Reader y Writer son las superclases abstractas para

Reader y Writer son las superclases abstractas para streams de caracteres en java.io. Reader proporciona el API y una implementación para readers (streams que leen caracteres de 16-bits) y Writer proporciona el API y una implementación para writers (streams que escriben caracteres de 16-bits).

I/O EN JAVA • Streams de Caracteres: – Reader y Writer son las superclases abstractas para
Streams de Bytes: I/O EN JAVA – Los programas deberían usar los streams de bytes, descendientes
Streams de Bytes: I/O EN JAVA – Los programas deberían usar los streams de bytes, descendientes

Streams de Bytes:

I/O EN JAVA

Streams de Bytes: I/O EN JAVA – Los programas deberían usar los streams de bytes, descendientes

Los programas deberían usar los streams de bytes, descendientes de InputStream y OutputStream, para leer y escribir bytes de 8-bits. Estos streams se usan normalmente para leer y escribir datos binarios

como imágenes y sonidos.

Streams de Bytes: I/O EN JAVA – Los programas deberían usar los streams de bytes, descendientes
Streams de Bytes: I/O EN JAVA – Los programas deberían usar los streams de bytes, descendientes
I/O EN JAVA Lectura de un fichero de texto: – Si necesitamos leer la información almacenada
I/O EN JAVA Lectura de un fichero de texto: – Si necesitamos leer la información almacenada

I/O EN JAVA

Lectura de un fichero de texto:

I/O EN JAVA Lectura de un fichero de texto: – Si necesitamos leer la información almacenada

Si necesitamos leer la información almacenada en un fichero de texto haremos uso de los streams de caracteres siguientes:

– Si necesitamos leer la información almacenada en un fichero de texto haremos uso de los

Reader es una clase base abstracta para leer streams de caracteres.

La clase InputStreamReader se encarga de leer bytes y convertirlos a carácter según unas reglas de conversión definidas para cambiar entre 16-bit Unicode y otras representaciones específicas de la plataforma.

FileReader es una clase para leer ficheros de caracteres. Los constructores de esta clase asumen que la codificación de caracteres es la de por defecto y el tamaño del buffer de bytes es el apropiado.

La clase BufferedReader lee texto desde un stream de entrada de caracteres, almacenando los caracteres leídos. Proporciona un buffer de almacenamiento temporal. Esta clase tiene el método readLine() para leer una línea de texto a la vez. Sin embargo, BufferedReader no puede usarse por sí mismo, debemos envolver un Reader dentro de un BufferedReader.

I/O EN JAVA Lectura de un fichero de texto: import java.io.*; public class LeeFichero { public
I/O EN JAVA Lectura de un fichero de texto: import java.io.*; public class LeeFichero { public

I/O EN JAVA

Lectura de un fichero de texto:

import java.io.*; public class LeeFichero {

public static void main(String[] args) {

String cad;

try

{

BufferedReader br = new BufferedReader(new FileReader("ejemplo.txt")); while ((cad = br.readLine()) != null) {

System.out.println(cad);

} //Cerramos el stream br.close();

} catch (IOException ioe) {

System.out.println(ioe);

}

}

}

I/O EN JAVA Lectura de un fichero de texto: import java.io.*; public class LeeFichero { public

8

I/O EN JAVA Escritura de un fichero de texto 1: – Para crear un stream de
I/O EN JAVA Escritura de un fichero de texto 1: – Para crear un stream de

I/O EN JAVA

Escritura de un fichero de texto 1:

I/O EN JAVA Escritura de un fichero de texto 1: – Para crear un stream de

Para crear un stream de salida, tenemos la clase Writer y sus descendientes. Podemos realizarlo de dos formas distintas, bien usando un objeto de tipo BufferedWriter o bien uno de tipo PrintWriter.

– Para crear un stream de salida, tenemos la clase Writer y sus descendientes. Podemos realizarlo

La primera forma de escribir un fichero de texto es utilizar la clase

BufferedWriter que proporciona un buffer de almacenamiento temporal. Los datos se escriben en el buffer, y cuando éste se llena, los

contenidos se escriben a un fichero, lo que reduce el número de veces que se tiene que acceder al disco o a la red.

Un objeto BufferedWriter envuelve un objeto FileWriter, entonces se llama al método write para escribir los datos en el fichero especificado. Es importante utilizar los métodos flush y close para vaciar el buffer y cerrar el fichero para liberar recursos.

I/O EN JAVA Escritura de un fichero de texto 1: import java.io.*; public class EscribeFichero1 {
I/O EN JAVA Escritura de un fichero de texto 1: import java.io.*; public class EscribeFichero1 {

I/O EN JAVA

Escritura de un fichero de texto 1:

import java.io.*; public class EscribeFichero1 {

public static void main(String[] args)

I/O EN JAVA Escritura de un fichero de texto 1: import java.io.*; public class EscribeFichero1 {

{

 

String cad1 = "Esto es una cadena."; String cad2 = "Esto es otra cadena."; try {

BufferedWriter bw = new BufferedWriter(new FileWriter("salida.txt"));

bw.write(cad1);

bw.newLine();

bw.write(cad2);

bw.flush();

//Cerramos el stream bw.close();

}

catch (IOException ioe)

{

System.out.println("Error IO: "+ioe.toString());

}

}

}

I/O EN JAVA Escritura de un fichero de texto 2: – La otra forma de escribir

I/O EN JAVA

I/O EN JAVA Escritura de un fichero de texto 2: – La otra forma de escribir

Escritura de un fichero de texto 2:

I/O EN JAVA Escritura de un fichero de texto 2: – La otra forma de escribir

La otra forma de escribir ficheros de texto consiste en utilizar la clase PrintWriter ya que proporciona métodos que facilitan la escritura de valores de tipo primitivo y objetos en un stream de caracteres.

Los métodos principales que proporciona son print y println, más convenientes de utilizar que los métodos write. El método println añade una nueva línea después de escribir su parámetro.

La clase PrintWriter se basa en un objeto BufferedWriter para el almacenamiento temporal de los caracteres y su posterior escritura en el fichero.

I/O EN JAVA Escritura de un fichero de texto 2: import java.io.*; public class EscribeFichero2 {
I/O EN JAVA Escritura de un fichero de texto 2: import java.io.*; public class EscribeFichero2 {

I/O EN JAVA

Escritura de un fichero de texto 2:

import java.io.*; public class EscribeFichero2 {

public static void main(String[] args)

I/O EN JAVA Escritura de un fichero de texto 2: import java.io.*; public class EscribeFichero2 {

{

 

String cad1 = "Esto es una cadena."; String cad2 = "Esto es otra cadena.";

try

{

PrintWriter salida

= new PrintWriter(new BufferedWriter(new FileWriter("salida.txt")));

salida.println(cad1);

salida.println(cad2);

//Cerramos el stream salida.close();

}

catch (IOException ioe) {

System.out.println("Error IO: "+ioe.toString());

}

}

}

12

SERIALIZACIÓN DE OBJETOS • Cuando ejecutamos una aplicación OO lo normal es crear múltiples instancias de

SERIALIZACIÓN DE OBJETOS

Cuando ejecutamos una aplicación OO lo normal es crear múltiples instancias de las clases que tengamos definidas en el sistema. Cuando cerramos esta aplicación todos los objetos que tengamos en memoria se pierden.

SERIALIZACIÓN DE OBJETOS • Cuando ejecutamos una aplicación OO lo normal es crear múltiples instancias de

Para solucionar este problema los lenguajes de POO nos proporcionan unos mecanismos especiales para poder guardar y recuperar el estado de un objeto y de esa manera poder utilizarlo como si no lo hubiéramos eliminado de la memoria. Este tipo de mecanismos se conoce como persistencia de los objetos.

En Java:

Interfaz Serializable (vacía)

– – Streams: ObjectOutputStream y ObjectInputStream.

Por ejemplo: class Clase implements Serializable, a partir de esta

declaración

los

persistentes.

objetos

que

se

basen

en

esta

clase

pueden

ser

SERIALIZACIÓN DE OBJETOS • ObjectOutputStream y ObjectInputStream permiten leer y escribir grafos de objetos, es decir,

SERIALIZACIÓN DE OBJETOS

SERIALIZACIÓN DE OBJETOS • ObjectOutputStream y ObjectInputStream permiten leer y escribir grafos de objetos, es decir,

ObjectOutputStream y ObjectInputStream permiten leer y escribir grafos de objetos, es decir, escribir y leer los bytes que representan al objeto. El proceso de transformación de un objeto en un stream de bytes se denomina serialización.

Los objetos ObjectOutputStream y ObjectInputStream deben ser almacenados en ficheros, para hacerlo utilizaremos los streams de bytes FileOutputStream y FileInputStream, ficheros de acceso secuencial.

Para serializar objetos necesitamos:

un objeto FileOutputStream que nos permita escribir bytes en un fichero como por ejemplo:

FileOutputStream fos = new FileOutputStream("fichero.dat");

y un objeto ObjectOutputStream al que le pasamos el objeto anterior de

la siguiente forma:

ObjectOutputStream oos = new ObjectOutputStream(fos); almacenar objetos mediante writeObject() como sigue:

oos.writeObject(objeto); Cuando terminemos, debemos cerrar el fichero escribiendo:

SERIALIZACIÓN DE OBJETOS • Ejemplo de serialización de objetos de tipo persona 1: public class Persona

SERIALIZACIÓN DE OBJETOS

Ejemplo de serialización de objetos de tipo persona 1:

public class Persona implements Serializable { } class Fecha2 implements Serializable { }

SERIALIZACIÓN DE OBJETOS • Ejemplo de serialización de objetos de tipo persona 1: public class Persona

/*******************************************************************************************************/ Persona obj1 = new Persona( "06634246S", "Javier García", f1, "calle1", 546551687 ); Persona obj4 = new Persona( "15664386T", "Carmen Pérez", f4, "calle4", 858789019 );

/*******************************************************************************************************/

//Serialización de las personas 1 FileOutputStream fosPer = new FileOutputStream("copiasegPer.dat");

ObjectOutputStream oosPer = new ObjectOutputStream(fosPer); oosPer.writeObject(obj1); oosPer.writeObject(obj4); /*******************************************************************************************************/

//Lectura de los objetos de tipo persona

FileInputStream fisPer = new FileInputStream("copiasegPer.dat"); ObjectInputStream oisPer = new ObjectInputStream(fisPer); try {

while (true) { Persona per = (Persona) oisPer.readObject(); System.out.println (per.toString());

} } catch (EOFException e) { System.out.println ("Lectura de los objetos de tipo Persona finalizada");

}

fisPer.close();

15

SERIALIZACIÓN DE OBJETOS • Ejemplo de serialización de objetos de tipo persona 2: public class Persona

SERIALIZACIÓN DE OBJETOS

Ejemplo de serialización de objetos de tipo persona 2:

SERIALIZACIÓN DE OBJETOS • Ejemplo de serialización de objetos de tipo persona 2: public class Persona

public class Persona implements Serializable { } class Fecha implements Serializable { } /*******************************************************************************************************/ Persona obj1 = new Persona( "06634246S", "Javier García", f1, "calle1", 546551687 ); Persona obj4 = new Persona( "15664386T", "Carmen Pérez", f4, "calle4", 858789019 ); //Introducimos los objetos en una tabla hash HashMap<String, Persona> personas = new HashMap<String, Persona>(); personas.put(obj1.getDni(), obj1); personas.put(obj4.getDni(), obj4);

/*******************************************************************************************************/

//Serialización de la tabla hash personas

FileOutputStream fosPer = new FileOutputStream("copiasegPer.dat"); ObjectOutputStream oosPer = new ObjectOutputStream(fosPer); oosPer.writeObject(personas); fosPer.close();

/*******************************************************************************************************/

//Lectura de los objetos de tipo persona a través de la tabla hash personas

FileInputStream fisPer = new FileInputStream("copiasegPer.dat"); ObjectInputStream oisPer = new ObjectInputStream(fisPer); try { while (true) {

personas = (HashMap) oisPer.readObject();

System.out.println (personas.toString());

} } catch (EOFException e) { System.out.println ("Lectura de los objetos de tipo Persona finalizada");

}

fisPer.close();

ORDENACIÓN DE OBJETOS

ORDENACIÓN DE OBJETOS • Se necesita un objeto Comparator que nos proporcionará la forma en la
ORDENACIÓN DE OBJETOS • Se necesita un objeto Comparator que nos proporcionará la forma en la

Se necesita un objeto Comparator que nos proporcionará la forma en la que debemos ordenar la colección a través del método compareTo().

//Comparador para ordenar las personas por su DNI Comparator DniPerComp = new Comparator() { public int compare(Object o1, Object o2) {

Persona per1 = (Persona) o1;

Persona per2 = (Persona) o2; return per1.getDni().compareTo(per2.getDni());

};

}

//Comparador para ordenar las personas por su tfno Comparator TfnoPerComp = new Comparator() { public int compare(Object o1, Object o2) { Persona per1 = (Persona) o1;

Persona per2 = (Persona) o2;

Integer t1 = new Integer(per1.getTfno()); Integer t2 = new Integer(per2.getTfno()); return t1.compareTo(t2);

}

ORDENACIÓN DE OBJETOS

ORDENACIÓN DE OBJETOS • Ordenación de los objetos de una tabla hash a través de un

ORDENACIÓN DE OBJETOS • Ordenación de los objetos de una tabla hash a través de un

Ordenación de los objetos de una tabla hash a través de un array por el atributo que seleccionemos. Búsquedas por atributo.

//Introducimos los objetos en una tabla hash HashMap<String, Persona> personas = new HashMap<String, Persona>();

personas.put(obj1.getDni(), obj1);

personas.put(obj4.getDni(), obj4);

//Convertimos la tabla hash en un array de objetos

Object personasA[] = personas.values().toArray(); //Ordenamos los objetos del array por el atributo DNI Arrays.sort(personasA, DniPerComp); //Buscamos una persona por su nombre BufferedReader entrada =

new BufferedReader(new InputStreamReader(System.in));

System.out.println("\nIntroduce el nombre de la persona a buscar:"); String nombre = entrada.readLine(); Persona paux; for (int i=0; i<personasA.length; i++) { paux = (Persona) personasA[i];

if (paux.getNombre().equals(nombre)) {

System.out.println("\nDatos de la persona:"); System.out.println(paux.toString()); break; } else if (i == personasA.length-1) System.out.println("\nPersona no encontrada.");

}

18

ORDENACIÓN DE OBJETOS

ORDENACIÓN DE OBJETOS • Ordenación de los objetos de un ArrayList por el atributo que seleccionemos
ORDENACIÓN DE OBJETOS • Ordenación de los objetos de un ArrayList por el atributo que seleccionemos

Ordenación de los objetos de un ArrayList por el atributo que seleccionemos y búsqueda de un elemento.

//Introducimos los objetos en un ArrayList ArrayList<Persona> personas = new ArrayList<Persona>();

personas.add(obj1);

personas.add(obj4);

//Ordenamos los objetos del ArrayList por el atributo DNI

Collections.sort(personas, DniPerComp); //Buscamos una persona por su nombre BufferedReader entrada= new BufferedReader(new InputStreamReader(System.in)); System.out.println("\nIntroduce el nombre de la persona a buscar:"); String nombre = entrada.readLine(); //creamos una persona con el nombre a buscar Persona p = new Persona(); p.setNombre(nombre); int pos = Collections.binarySearch(personas, p, NomPerComp);

if (pos>=0) {

System.out.println("\nDatos de la persona:"); Persona per = personas.get(pos); System.out.println(per.toString()); } else System.out.println("\n Persona no encontrada.");

19

TIPOS DE OBJETOS EN

COLECCIONES

Para saber con que clase se instanció un objeto se debe utilizar el método getClass de la clase Object, si lo complementamos con getName de la clase Class, nos devuelve una cadena con el nombre de la clase.

TIPOS DE OBJETOS EN COLECCIONES Para saber con que clase se instanció un objeto se debe

TIPOS DE OBJETOS EN COLECCIONES Para saber con que clase se instanció un objeto se debe

Ejemplo: Tenemos una jerarquía de clases que pertenecen a un paquete “censouni” e introducimos diversos objetos en una tabla hash de tipo Persona:

HashMap<String, Persona> personas = new HashMap<String, Persona>();

Persona obj1 = new Profesor(); personas.put(obj1.getDni(), obj1);

Persona obj4 = new Alumno(); personas.put(obj4.getDni(), obj4);

TIPOS DE OBJETOS EN COLECCIONES Para saber con que clase se instanció un objeto se debe

//recuperamos una persona

Persona objper = personas.get(dni);

String clase = objper.getClass().getName(); if (clase.equals("censouni.Alumno")) { Alumno alumno = (censouni.Alumno) objper; System.out.println("- Titulación: " + alumno.getTitulacion()); System.out.println("- Asignaturas: " + alumno.getAsignaturas()); } else if (clase.equals("censouni.Profesor")) { Profesor profe = (censouni.Profesor) objper; System.out.println("- Departamento: " + profe.getDepartamento()); System.out.println("- Sueldo: " + profe.getSueldo());

}

20

DOCUMENTACIÓN DE PROGRAMAS • Cuando se llega a la fase de implementación del sistema una de

DOCUMENTACIÓN DE

PROGRAMAS

DOCUMENTACIÓN DE PROGRAMAS • Cuando se llega a la fase de implementación del sistema una de

Cuando se llega a la fase de implementación del sistema una de las tareas a realizar además de la codificación del código es su documentación, para ello conforme se codifican clases es conveniente ir documentándolas.

En Java hay que seguir unas sencillas reglas para comentar los programas y utilizar la herramienta javadoc incluida en el jdk.

Todos los comentarios introducidos en el código mediante /** y */ serán incluidos en la documentación del código generada en javadoc.

Los comentarios de documentación describen las líneas de código que se sitúan a continuación. Se pueden incluir etiquetas html ya que la documentación se genera en este lenguaje.

Solo se procesan los comentarios de documentación inmediatamente anteriores a una clase, interfaz, método o atributo. Si no se proporciona un comentario de documentación para un método heredado, el método “hereda” el comentario de su padre.

21

DOCUMENTACIÓN DE PROGRAMAS • Los comentarios de documentación pueden incluir etiquetas que almacenan tipos de información

DOCUMENTACIÓN DE

PROGRAMAS

DOCUMENTACIÓN DE PROGRAMAS • Los comentarios de documentación pueden incluir etiquetas que almacenan tipos de información

Los comentarios de documentación pueden incluir etiquetas que almacenan tipos de información particulares. Todas las etiquetas empiezan con el símbolo @.

Las etiquetas más interesantes son las siguientes:

@param: documenta un solo parámetro de un método.

@return: documenta el valor de retorno de un método.

@throws o @exception: documenta una excepción lanzada por un método.

@author: especifica el autor del código

– – @version: especifica la versión del código

Para generar la documentación (si no tenemos entorno de desarrollo), debemos ir al directorio donde tengamos el código

fuente y ejecutar el siguiente comando: javadoc *.java -private d javadoc de esta forma generamos la documentación en un directorio llamado javadoc de todos los programas.

22

DOCUMENTACIÓN DE PROGRAMAS • NetBeans: Para generar la documentación de un proyecto seleccionamos Build – Generate

DOCUMENTACIÓN DE

PROGRAMAS

DOCUMENTACIÓN DE PROGRAMAS • NetBeans: Para generar la documentación de un proyecto seleccionamos Build – Generate

NetBeans: Para generar la documentación de un proyecto seleccionamos Build Generate Javadoc.

Previamente debemos modificar las propiedades del proyecto para que incluya los atributos y métodos privados:

DOCUMENTACIÓN DE PROGRAMAS • NetBeans: Para generar la documentación de un proyecto seleccionamos Build – Generate
DOCUMENTACIÓN DE PROGRAMAS • EJEMPLO: 24

DOCUMENTACIÓN DE

PROGRAMAS

EJEMPLO:

DOCUMENTACIÓN DE PROGRAMAS • EJEMPLO: 24
DOCUMENTACIÓN DE PROGRAMAS • EJEMPLO: 24

24

DOCUMENTACIÓN DE PROGRAMAS public class Persona { /** Atributo para almacenar el DNI de una persona

DOCUMENTACIÓN DE

PROGRAMAS

DOCUMENTACIÓN DE PROGRAMAS public class Persona { /** Atributo para almacenar el DNI de una persona

public class Persona { /** Atributo para almacenar el DNI de una persona */ private String dni; /** Atributo para almacenar el nombre de una persona */ private String nombre; /** Devuelve el Nombre de una persona */ public String getNombre() { return this.nombre; } /** Establece el Nombre de una persona */ public void setNombre(String nombre) { this.nombre = nombre; }

}

/** Establece el sueldo del empleado

* @param horas Horas trabajadas * @param precioHora Precio de la hora trabajada * @throws SueldoMal El sueldo es incorrecto */ public void setSueldo(double horas, double precioHora) { try { if (horas <= 0 || precioHora <= 0) throw new SueldoMal();

this.sueldo = horas * precioHora; } catch (SueldoMal sm) { System.out.println( "\n" + sm.getMessage() ); }

} /** Imprime el nombre y el departamento del Empleado * @return Información de los datos del empleado */ public String toString() {

return super.toString() + " # Departamento: " + dept.toString();

}

25