lenguaje java avanzado

Lenguaje Java Avanzado

ndice1 Introduccin al lenguaje Java....................................................................................... 4

1.1 Java.......................................................................................................................... 41.2 Conceptos previos de POO...................................................................................... 51.3 Componentes de un programa Java......................................................................... 71.4 Herencia e interfaces..............................................................................................161.5 Hilos.......................................................................................................................191.6 Clases tiles........................................................................................................... 231.7 Estructuras de datos............................................................................................... 29

2 Ejercicios de Introduccin al lenguaje Java............................................................... 312.1 Uso de interfaces (1 punto).................................................................................... 312.2 Refactorizacin (1 punto)...................................................................................... 322.3 Documentacin (0.5 puntos)..................................................................................322.4 Centro cultural (1 punto)........................................................................................322.5 Copia de propiedades con BeanUtils (0.5 puntos).................................................33

3 Colecciones de datos.................................................................................................. 343.1 Colecciones............................................................................................................ 343.2 Comparacin de objetos.........................................................................................453.3 Polimorfismo e interfaces...................................................................................... 473.4 Tipos de datos bsicos en las colecciones..............................................................48

4 Ejercicios de colecciones............................................................................................504.1 Implementaciones e interfaces (1 punto)............................................................... 504.2 Uso de listas (1 punto)........................................................................................... 50

5 Tratamiento de errores................................................................................................525.1 Introduccin........................................................................................................... 525.2 Errores en tiempo de ejecucin: Excepciones....................................................... 525.3 Errores en tiempo de compilacin......................................................................... 57

Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All rights reserved.

6 Ejercicios de tratamiento de errores........................................................................... 646.1 Captura de excepciones (0.5 puntos)..................................................................... 646.2 Lanzamiento de excepciones (0.5 puntos)............................................................. 646.3 Excepciones como tipos genricos en la aplicacin filmotecas(0.5 puntos)......... 666.4 Excepciones anidadas en la aplicacin filmotecas (1.5 puntos)............................ 66

7 Casos de prueba: JUnit............................................................................................... 687.1 Introduccin a JUnit...............................................................................................687.2 Integracin de JUnit en Eclipse............................................................................. 687.3 Un ejemplo sencillo............................................................................................... 707.4 Fixtures.................................................................................................................. 797.5 Objetos mock......................................................................................................... 817.6 Suites de pruebas....................................................................................................87

8 Ejercicios de JUnit......................................................................................................898.1 Pruebas del gestor de filmotecas (2 puntos).......................................................... 898.2 Desarrollo guiado por pruebas (1 punto)............................................................... 90

9 Serializacin de datos.................................................................................................929.1 Introduccin........................................................................................................... 929.2 Flujos de datos de entrada/salida........................................................................... 929.3 Entrada, salida y salida de error estndar...............................................................939.4 Acceso a ficheros................................................................................................... 949.5 Acceso a los recursos............................................................................................. 959.6 Acceso a la red....................................................................................................... 969.7 Codificacin de datos.............................................................................................969.8 Serializacin de objetos......................................................................................... 97

10 Ejercicios de Serializacin........................................................................................9910.1 Leer un fichero de texto (0.5 puntos)................................................................... 9910.2 Lectura de una URL (0.5 puntos).........................................................................9910.3 Gestin de productos (1 punto)............................................................................ 9910.4 Guardar datos de la filmoteca (1 punto).............................................................100

11 Depuracin y gestin de logs..................................................................................10211.1 Depuracin con Eclipse......................................................................................10211.2 Gestin de logs con Log4Java............................................................................107


2Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All rights reserved.

11.3 La librera commons-logging............................................................................. 11412 Ejercicios de depuracin y logging.........................................................................118

12.1 Depuracin de cdigo (1.5 puntos).................................................................... 11812.2 Logs al leer ficheros (1.5 puntos).......................................................................118

13 Java Database Connectivity....................................................................................12013.1 Introduccin a JDBC..........................................................................................12013.2 Consulta a una base de datos con JDBC............................................................ 12413.3 Restricciones y movimientos en el ResultSet.................................................... 12713.4 Sentencias de actualizacin................................................................................12913.5 Otras llamadas a la BD.......................................................................................13013.6 Optimizacin de sentencias................................................................................13113.7 Transacciones..................................................................................................... 133

14 Ejercicios de Java Database Connectivity.............................................................. 13614.1 Filmoteca en MySQL......................................................................................... 13614.2 Conectar con la base de de datos (0.5 puntos)................................................... 13714.3 Consulta sin parmetros (0.5 puntos).................................................................13714.4 Sentencias preparadas (0.5 puntos).................................................................... 13814.5 Sentencias de borrado de registros (0.5 puntos).................................................13814.6 Sentencias de insercin de registros y valores autoincrementados (0.5 puntos)13814.7 Transacciones (0.5 puntos).................................................................................139

15 Pruebas con DBUnit............................................................................................... 14015.1 Introduccin....................................................................................................... 14015.2 DbUnit................................................................................................................14015.3 Prcticas recomendadas......................................................................................14115.4 Clases e interfaces.............................................................................................. 14115.5 Estructura en un proyecto...................................................................................142

16 Ejercicios de DbUnit...............................................................................................14616.1 Generar el XML de DbUnit (0.5 puntos)........................................................... 14616.2 Clase para los test de DbUnit (1 punto)............................................................. 14616.3 Test de borrado y aadido (0.5 puntos)..............................................................14616.4 Test que espera una excepcin (0.5 puntos).......................................................14716.5 Test de borrado (0.5 puntos).............................................................................. 147



1. Introduccin al lenguaje Java

1.1. Java

Java es un lenguaje de programacin creado por Sun Microsystems, (empresa queposteriormente fue comprada por Oracle) para poder funcionar en distintos tipos deprocesadores. Su sintaxis es muy parecida a la de C o C++, e incorpora como propiasalgunas caractersticas que en otros lenguajes son extensiones: gestin de hilos, ejecucinremota, etc.

El cdigo Java, una vez compilado, puede llevarse sin modificacin alguna sobrecualquier mquina, y ejecutarlo. Esto se debe a que el cdigo se ejecuta sobre unamquina hipottica o virtual, la Java Virtual Machine, que se encarga de interpretar elcdigo (ficheros compilados .class) y convertirlo a cdigo particular de la CPU que seest utilizando (siempre que se soporte dicha mquina virtual).

1.1.1. Certificacin Sun / Oracle

Aunque el resto del curso de Experto est orientado a certificaciones en el mbito de JEE,este mdulo de Java y Herramientas de Desarrollo se basa en las certificaciones para Javabsico o estndar. Dichas certificaciones son dos: Oracle Certified Professional Java Programmer (antes SCJP - Sun Certified Java

Programmer):http://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=320

Oracle Certified Master, Java SE 6 Developer (antes SCJD - Sun Certified JavaDevelopper):http://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=321

Para la primera (SCJP), se debe completar un examen. En el caso del certificado para laplataforma Java 1.5, el examen abarca los siguientes apartados generales: Seccin 1: Declaraciones, inicializaciones y mbitos: evala si el alumno es capaz

de escribir cdigo que declare clases o interfaces, utilice adecuadamente la estructurade paquetes e imports, utilice cdigo con tipos simples, arrays, objetos estticos,variables locales, constructores, mtodos estticos y no estticos, sobrecarga demtodos, etc

Seccin 2: Control de flujo: uso de sentencias if, switch, bucles (for, do,while, break, continue), manejo y uso de excepciones (try-catch-finally), etc

Seccin 3: Contenidos del API: uso de wrappers bsicos (Integer, Boolean, etc),entrada/salida de ficheros, serializacin de objetos para E/S, formateo de datos con elpaquete java.text, y parseo de cadenas mediante expresiones regulares y similares(paquetes java.util y java.util.regex)

Seccin 4: Concurrencia: manejo de hilos (mediante Thread y mediante Runnable),



estados de los hilos, interbloqueos y sincronizacin Seccin 5: Conceptos sobre orientacin a objetos: desarrollo de cdigo que cumpla

los requerimientos de encapsulamiento, cohesin y acoplamiento entre clases (muchacohesin, poco acoplamiento). Uso del polimorfismo y del casting. Uso de mtodossobrecargados, llamadas a la superclase, etc.

Seccin 6: Colecciones: determinar qu tipos de colecciones (listas, hashmaps, etc)utilizar en diferentes supuestos. Comparaciones y ordenaciones entre objetos de unacoleccin, etc

Seccin 7: Fundamentos: uso correcto de los modificadores de acceso, declaracionesde paquetes, imports. Seguimiento de trazas. Manejo de referencias a objetos. Uso delrecolector de basura... etc

Para la segunda (SCJD) es necesario haber obtenido antes la primera certificacin(SCJP). Despus, se deben superar dos pruebas: un supuesto de programacin, y unexamen.

La primera prueba (el supuesto de programacin), consiste en escribir cdigo paraimplementar una supuesta aplicacin para empresa. Se evaluarn aspectos comodocumentacin, diseo orientado a objetos, desarrollo de la interfaz grfica,interbloqueos, etc.

La segunda prueba (el examen), es una explicacin sobre el desarrollo que hayamoshecho en el supuesto de programacin anterior, explicando las decisiones principales quehemos tenido que tomar, ventajas y desventajas de las mismas, y justificacin de dichasdecisiones, en funcin de los objetivos propuestos para la implementacin.Ms informacin sobre las certificaciones en los enlaces respectivos vistos antes.

1.1.2. Recursos adicionales

1.1.2.1. Bibliografa

Curso de Java, Ian F. Darwin, Ed. Anaya Multimedia, Coleccin O'Reilly Java 2 v5.0, Varios autores, Ed. Anaya Multimedia, Coleccin Wrox Piensa en Java, Bruce Eckel, Ed. Prentice Hall Core Java 2, Cay Horstmann y Gary Cornell, Ed. Prentice Hall PTR Java in a Nutshell, David Flanagan, Ed. O'Reilly Media

1.1.2.2. Enlaces

Web oficial de Java, http://www.oracle.com/technetwork/java/index.html

1.2. Conceptos previos de POO

Java es un lenguaje orientado a objetos (OO), por lo que, antes de empezara ver qu



elementos componen los programas Java, conviene tener claros algunos conceptos de laprogramacin orientada a objetos (POO).

1.2.1. Concepto de clase y objetoEl elemento fundamental a la hora de hablar de programacin orientada a objetos es elconcepto de objeto en s, as como el concepto abstracto de clase. Un objeto es unconjunto de variables junto con los mtodos relacionados con stas. Contiene lainformacin (las variables) y la forma de manipular la informacin (los mtodos). Unaclase es el prototipo que define las variables y mtodos que va a emplear un determinadotipo de objeto, es la definicin abstracta de lo que luego supone un objeto en memoria.Poniendo un smil fuera del mundo de la informtica, la clase podra ser el concepto decoche, donde nos vienen a la memoria los parmetros que definen un coche (dimensiones,cilindrada, maletero, etc), y las operaciones que podemos hacer con un coche (acelerar,frenar, adelantar, estacionar). La idea abstracta de coche que tenemos es lo queequivaldra a la clase, y la representacin concreta de coches concretos (por ejemplo,Peugeot 307, Renault Megane, Volkswagen Polo...) seran los objetos de tipo coche.

1.2.2. Concepto de campo, mtodo y constructor

Toda clase u objeto se compone internamente de constructores, campos y/o mtodos.Veamos qu representa cada uno de estos conceptos: un campo es un elemento quecontiene informacin relativa a la clase, y un mtodo es un elemento que permitemanipular la informacin de los campos. Por otra parte, un constructor es un elementoque permite reservar memoria para almacenar los campos y mtodos de la clase, a la horade crear un objeto de la misma.

1.2.3. Concepto de herencia y polimorfismo

Con la herencia podemos definir una clase a partir de otra que ya exista, de forma que lanueva clase tendr todas las variables y mtodos de la clase a partir de la que se crea, mslas variables y mtodos nuevos que necesite. A la clase base a partir de la cual se crea lanueva clase se le llama superclase.

Por ejemplo, podramos tener una clase genrica Animal, y heredamos de ella para formarclases ms especficas, como Pato, Elefante, o Len. Estas clases tendran todo lo de laclase padre Animal, y adems cada una podra tener sus propios elementos adicionales.

Una caracterstica derivada de la herencia es que, por ejemplo, si tenemos un mtododibuja(Animal a), que se encarga de hacer un dibujo del animal que se le pasa comoparmetro, podremos pasarle a este mtodo como parmetro tanto un Animal como unPato, Elefante, o cualquier otro subtipo directo o indirecto de Animal. Esto se conocecomo polimorfismo.



1.2.4. Modificadores de acceso

Tanto las clases como sus elementos (constructores, campos y mtodos) pueden versemodificados por lo que se suelen llamar modificadores de acceso, que indican hastadnde es accesible el elemento que modifican. Tenemos tres tipos de modificadores: privado: el elemento es accesible nicamente dentro de la clase en la que se

encuentra. protegido: el elemento es accesible desde la clase en la que se encuentra, y adems

desde las subclases que hereden de dicha clase. pblico: el elemento es accesible desde cualquier clase.

1.2.5. Clases abstractas e interfaces

Mediante las clases abstractas y los interfaces podemos definir el esqueleto de unafamilia de clases, de forma que los subtipos de la clase abstracta o la interfazimplementen ese esqueleto para dicho subtipo concreto. Por ejemplo, volviendo con elejemplo anterior, podemos definir en la clase Animal el mtodo dibuja() y el mtodoimprime(), y que Animal sea una clase abstracta o un interfaz.Vemos la diferencia entre clase, clase abstracta e interfaz con este supuesto: En una clase, al definir Animal tendramos que implementar el cdigo de los mtodos

dibuja() e imprime(). Las subclases que hereden de Animal no tendran por quimplementar los mtodos, a no ser que quieran redefinirlos para adaptarlos a suspropias necesidades.

En una clase abstracta podramos implementar los mtodos que nos interese, dejandosin implementar los dems (dejndolos como mtodos abstractos). Dichos mtodostendran que implementarse en las clases hijas.

En un interfaz no podemos implementar ningn mtodo en la clase padre, y cadaclase hija tiene que hacer sus propias implementaciones de los mtodos. Adems, lasclases hijas podran implementar otros interfaces.

1.3. Componentes de un programa Java

En un programa Java podemos distinguir varios elementos:

1.3.1. Clases

Para definir una clase se utiliza la palabra reservada class, seguida del nombre de laclase:

class MiClase{...

}



Es recomendable que los nombres de las clases sean sustantivos (ya que suelenrepresentar entidades), pudiendo estar formados por varias palabras. La primera letra decada palabra estar en mayscula y el resto de letras en minscula. Por ejemplo,DatosUsuario, Cliente, GestorMensajes.

Cuando se trate de una clase encargada nicamente de agrupar un conjunto de recursos ode constantes, su nombre se escribir en plural. Por ejemplo, Recursos, MensajesError.

1.3.2. Campos y variables

Dentro de una clase, o de un mtodo, podemos definir campos o variables,respectivamente, que pueden ser de tipos simples, o clases complejas, bien de la API deJava, bien que hayamos definido nosotros mismos, o bien que hayamos copiado de otrolugar.

Al igual que los nombres de las clases, suele ser conveniente utilizar sustantivos quedescriban el significado del campo, pudiendo estar formados tambin por varias palabras.En este caso, la primera palabra comenzar por minscula, y el resto por mayscula. Porejemplo, apellidos, fechaNacimiento, numIteraciones.De forma excepcional, cuando se trate de variables auxiliares de corto alcance se puedeponer como nombre las iniciales del tipo de datos correspondiente:

int i;Vector v;MiOtraClase moc;

Por otro lado, las constantes se declaran como final static, y sus nombres esescribirn totalmente en maysculas, separando las distintas palabras que los formen porcaracteres de subrayado ('_'). Por ejemplo, ANCHO_VENTANA, MSG_ERROR_FICHERO.

1.3.3. Mtodos

Los mtodos o funciones se definen de forma similar a como se hacen en C: indicando eltipo de datos que devuelven, el nombre del mtodo, y luego los argumentos entreparntesis:

void imprimir(String mensaje){

... // Cdigo del mtodo}

double sumar(double... numeros){//Nmero variable de argumentos//Se accede a ellos como a un vector://numeros[0], numeros[1], ...

}

Vector insertarVector(Object elemento, int posicion){




Al igual que los campos, se escriben con la primera palabra en minsculas y el restocomenzando por maysculas. En este caso normalmente utilizaremos verbos.

NotaUna vez hayamos creado cualquier clase, campo o mtodo, podremos modificarlo pulsando conel botn derecho sobre l en el explorador de Eclipse y seleccionando la opcin Refactor >Rename... del men emergente. Al cambiar el nombre de cualquiera de estos elementos, Eclipseactualizar automticamente todas las referencias que hubiese en otros lugares del cdigo.Adems de esta opcin para renombrar, el men Refactor contiene bastantes ms opciones quenos permitirn reorganizar automticamente el cdigo de la aplicacin de diferentes formas.

1.3.4. Constructores

Podemos interpretar los constructores como mtodos que se llaman igual que la clase, yque se ejecutan con el operador new para reservar memoria para los objetos que se creende dicha clase:

MiClase(){

... // Cdigo del constructor}

MiClase(int valorA, Vector valorV){

... // Cdigo de otro constructor}

No tenemos que preocuparnos de liberar la memoria del objeto al dejar de utilizarlo. Estolo hace automticamente el garbage collector. An as, podemos usar el mtodofinalize() para liberar manualmente.

Si estamos utilizando una clase que hereda de otra, y dentro del constructor de la subclasequeremos llamar a un determinado constructor de la superclase, utilizaremos super. Si nose hace la llamada a super, por defecto la superclase se construir con su constructorvaco. Si esta superclase no tuviese definido ningn constructor vaco, o bien quisiesemosutilizar otro constructor, podremos llamar a super proporcionando los parmetroscorrespondientes al constructor al que queramos llamar. Por ejemplo, si heredamos deMiClase y desde la subclase queremos utilizar el segundo constructor de la superclase, alcomienzo del constructor haremos la siguiente llamada a super:

SubMiClase(){

super(0, new Vector());... // Cdigo de constructor subclase

}

NotaPodemos generar el constructor de una clase automticamente con Eclipse, pulsando con el botnderecho sobre el cdigo y seleccionando Source > Generate Constructor Using Fields... o Source> Generate Constructors From Superclass...



1.3.5. Paquetes

Las clases en Java se organizan (o pueden organizarse) en paquetes, de forma que cadapaquete contenga un conjunto de clases. Tambin puede haber subpaquetesespecializados dentro de un paquete o subpaquete, formando as una jerarqua depaquetes, que despus se plasma en el disco duro en una estructura de directorios ysubdirectorios igual a la de paquetes y subpaquetes (cada clase ir en eldirectorio/subdirectorio correspondiente a su paquete/subpaquete).Cuando queremos indicar que una clase pertenece a un determinado paquete osubpaquete, se coloca al principio del fichero la palabra reservada package seguida porlos paquetes/subpaquetes, separados por '.' :

package paq1.subpaq1;...

class MiClase {...

Si queremos desde otra clase utilizar una clase de un paquete o subpaquete determinado(diferente al de la clase en la que estamos), incluimos una sentencia import antes de laclase (y despus de la lnea package que pueda tener la clase, si la tiene), indicando qupaquete o subpaquete queremos importar:

import paq1.subpaq1.*;

import paq1.subpaq1.MiClase;

La primera opcin (*) se utiliza para importar todas las clases del paquete (se utilizacuando queremos utilizar muchas clases del paquete, para no ir importando una a una). Lasegunda opcin se utiliza para importar una clase en concreto.

NotaEs recomendable indicar siempre las clases concretas que se estn importando y no utilizar el *.De esta forma quedar ms claro cuales son las clases que se utilizan realmente en nuestrocdigo. Hay diferentes paquetes que contienen clases con el mismo nombre, y si se importasenusando * podramos tener un problema de ambigedad.

Al importar, ya podemos utilizar el nombre de la clase importada directamente en la claseque estamos construyendo. Si no colocsemos el import podramos utilizar la clase igual,pero al referenciar su nombre tendramos que ponerlo completo, con paquetes ysubpaquetes:

MiClase mc; // Si hemos hecho el 'import' antes

paq1.subpaq1.MiClase mc; // Si NO hemos hecho el 'import' antes

Existe un paquete en la API de Java, llamado java.lang, que no es necesario importar.Todas las clases que contiene dicho paquete son directamente utilizables. Para el resto depaquetes (bien sean de la API o nuestros propios), ser necesario importarlos cuando



estemos creando una clase fuera de dichos paquetes.

Los paquetes normalmente se escribirn totalmente en minsculas. Es recomendableutilizar nombres de paquetes similares a la URL de nuestra organizacin pero a la inversa,es decir, de ms general a ms concreto. Por ejemplo, si nuestra URL eshttp://www.jtech.ua.es los paquetes de nuestra aplicacin podran recibir nombrescomo es.ua.jtech.proyecto.interfaz, es.ua.jtech.proyecto.datos, etc.

ImportanteNunca se debe crear una clase sin asignarle nombre de paquete. En este caso la clase seencontrara en el paquete sin nombre, y no podra ser referenciada por las clases del resto depaquetes de la aplicacin.

Con Eclipse podemos importar de forma automtica los paquetes necesarios. Para ellopodemos pulsar sobre el cdigo con el botn derecho y seleccionar Source > Organizeimports. Esto aadir y ordenar todos los imports necesarios. Sin embargo, esto nofuncionar si el cdigo tiene errores de sintaxis. En ese caso si que podramos aadir unimport individual, situando el cursor sobre el nombre que se quiera importar, pulsandocon el botn derecho, y seleccionando Source > Add import.

1.3.6. Tipo enumerado

El tipo enum permite definir un conjunto de posibles valores o estados, que luegopodremos utilizar donde queramos:

Ejemplo// Define una lista de 3 valores y luego comprueba en un switch// cul es el valor que tiene un objeto de ese tipoenum EstadoCivil {soltero, casado, divorciado};EstadoCivil ec = EstadoCivil.casado;ec = EstadoCivil.soltero;switch(ec){

case soltero: System.out.println("Es soltero");break;

case casado: System.out.println("Es casado");break;

case divorciado:System.out.println("Es divorciado");break;

}

Los elementos de una enumeracin se comportan como objetos Java. Por lo tanto, laforma de nombrar las enumeraciones ser similar a la de las clases (cada palabraempezando por mayscula, y el resto de clases en minscula).Como objetos Java que son, estos elementos pueden tener definidos campos, mtodos eincluso constructores. Imaginemos por ejemplo que de cada tipo de estado civil nosinteresase conocer la retencin que se les aplica en el sueldo. Podramos introducir estainformacin de la siguiente forma:



enum EstadoCivil {soltero(0.14f), casado(0.18f), divorciado(0.14f);private float retencion;

EstadoCivil(float retencion) {this.retencion = retencion;

}

public float getRetencion() {return retencion;

}};

De esta forma podramos calcular de forma sencilla la retencin que se le aplica a unapersona dado su salario y su estado civil de la siguiente forma:

public float calculaRetencion(EstadoCivil ec, float salario) {return salario * ec.getRetencion();

}

Dado que los elementos de la enumeracin son objetos, podramos crear nuevos mtodoso bien sobrescribir mtodos de la clase Object. Por ejemplo, podramos redefinir elmtodo toString para especificar la forma en la que se imprime cada elemento de laenumeracin (por defecto imprime una cadena con el nombre del elemento, por ejemplo"soltero").

1.3.7. Modificadores de acceso

Tanto las clases como los campos y mtodos admiten modificadores de acceso, paraindicar si dichos elementos tienen mbito pblico, protegido o privado. Dichosmodificadores se marcan con las palabras reservadas public, protected y private,respectivamente, y se colocan al principio de la declaracin:

public class MiClase {...

protected int b;...

private int miMetodo(int b) {...

El modificador protected implica que los elementos que lo llevan son visibles desde laclase, sus subclases, y las dems clases del mismo paquete que la clase.

Si no se especifica ningn modificador, el elemento ser considerado de tipo paquete.Este tipo de elementos podrn ser visibles desde la clase o desde clases del mismopaquete, pero no desde las subclases.

Cada fichero Java que creemos debe tener una y slo una clase pblica (que ser la claseprincipal del fichero). Dicha clase debe llamarse igual que el fichero. Aparte, el ficheropodr tener otras clases internas, pero ya no podrn ser pblicas.

Por ejemplo, si tenemos un fichero MiClase.java, podra tener esta apariencia:public class MiClase{



...

}

class OtraClase{

...

}

class UnaClaseMas{

...

}

Si queremos tener acceso a estas clases internas desde otras clases, deberemos declararlascomo estticas. Por ejemplo, si queremos definir una etiqueta para incluir en los puntos2D definidos en el ejemplo anterior, podemos definir esta etiqueta como clase interna(para dejar claro de esta forma que dicha etiqueta es para utilizarse en Punto2D). Parapoder manipular esta clase interna desde fuera deberemos declararla como esttica de lasiguiente forma:

public class Punto2D {...

static class Etiqueta {String texto;int tam;Color color;

}}

Podremos hacer referencia a ella desde fuera de Punto2D de la siguiente forma:Punto2D.Etiqueta etiq = new Punto2D.Etiqueta();

1.3.8. Otros modificadores

Adems de los modificadores de acceso vistos antes, en clases, mtodos y/o campos sepueden utilizar tambin estos modificadores: abstract: elemento base para la herencia (los objetos subtipo debern definir este

elemento). Se utiliza para definir clases abstractas, y mtodos abstractos dentro dedichas clases, para que los implementen las subclases que hereden de ella.

static: elemento compartido por todos los objetos de la misma clase. Con estemodificador, no se crea una copia del elemento en cada objeto que se cree de la clase,sino que todos comparten una sola copia en memoria del elemento, que se crea sinnecesidad de crear un objeto de la clase que lo contiene. Como se ha vistoanteriormente, tambin puede ser aplicado sobre clases, con un significado diferenteen este caso.

final: objeto final, no modificable (se utiliza para definir constantes) ni heredable(en caso de aplicarlo a clases).

synchronized: para elementos a los que no se puede acceder al mismo tiempo desdedistintos hilos de ejecucin.

Estos modificadores se colocan tras los modificadores de acceso:



// Clase abstracta para heredar de ellapublic abstract class Ejemplo{// Constante esttica de valor 10public static final TAM = 10;

// Mtodo abstracto a implementarpublic abstract void metodo();

public synchronized void otroMetodo(){

... // Aqu dentro slo puede haber un hilo a la vez}

}

NotaSi tenemos un mtodo esttico (static), dentro de l slo podremos utilizar elementosestticos (campos o mtodos estticos), o bien campos y mtodos de objetos que hayamos creadodentro del mtodo.

Por ejemplo, si tenemos:public class UnaClase{public int a;

public static int metodo(){

return a + 1;}

}

Dar error, porque el campo a no es esttico, y lo estamos utilizando dentro del mtodoesttico. Para solucionarlo tenemos dos posibilidades: definir a como esttico (si el diseodel programa lo permite), o bien crear un objeto de tipo UnaClase en el mtodo, y utilizarsu campo a (que ya no har falta que sea esttico, porque hemos creado un objeto y yapodemos acceder a su campo a):

public class UnaClase{public int a;

public static int metodo(){

UnaClase uc = new UnaClase();// ... Aqu haramos que uc.a tuviese el valor adecuadoreturn uc.a + 1;

}}

NotaPara hacer referencia a un elemento esttico utilizaremos siempre el nombre de la clase a la quepertenece, y no la referencia a una instancia concreta de dicha clase.

Por ejemplo, si hacemos lo siguiente:



UnaClase uc = new UnaClase();uc.metodo();

Aparecer un warning, debido a que el mtodo metodo no es propio de la instanciaconcreta uc, sino da la clase UnaClase en general. Por lo tanto, deberemos llamarlo con:

UnaClase.metodo();

1.3.9. Imports estticos

Los imports estticos permiten importar los elementos estticos de una clase, de formaque para referenciarlos no tengamos que poner siempre como prefijo el nombre de laclase. Por ejemplo, podemos utilizar las constantes de color de la clase java.awt.Color,o bien los mtodos matemticos de la case Math.

Ejemploimport static java.awt.Color;import static java.lang.Math;public class...{...

JLabel lbl = new JLabel();lbl.setBackground(white); // Antes sera Color.white

...

double raiz = sqrt(1252.2); // Antes sera Math.sqrt(...)}

1.3.10. Argumentos variables

Java permite pasar un nmero variable de argumentos a una funcin (como sucede confunciones como printf en C). Esto se consigue mediante la expresin "..." a partir delmomento en que queramos tener un nmero variable de argumentos.

Ejemplo// Funcion que tiene un parmetro String obligatorio// y n parmetros int opcionales

public void miFunc(String param, int... args){...

// Una forma de procesar n parametros variablesfor (int argumento: args){

...

}...

}

...

miFunc("Hola", 1, 20, 30, 2);miFunc("Adios");



1.3.11. Metainformacin o anotaciones

Se tiene la posibilidad de aadir ciertas anotaciones en campos, mtodos, clases y otroselementos, que permitan a las herramientas de desarrollo o de despliegue leerlas y realizarciertas tareas. Por ejemplo, generar ficheros fuentes, ficheros XML, o un Stub de mtodospara utilizar remotamente con RMI.

Un ejemplo ms claro lo tenemos en las anotaciones que ya se utilizan para laherramienta Javadoc. Las marcas @deprecated no afectan al comportamiento de losmtodos que las llevan, pero previenen al compilador para que muestre una advertenciaindicando que el mtodo que se utiliza est desaconsejado. Tambin se tienen otrasmarcas @param, @return, @see, etc, que utiliza Javadoc para generar las pginas dedocumentacin y las relaciones entre ellas.

1.3.12. Ejecucin de clases: mtodo mainEn las clases principales de una aplicacin (las clases que queramos ejecutar) debe haberun mtodo main con la siguiente estructura:

public static void main(String[] args){


Dentro pondremos el cdigo que queramos ejecutar desde esa clase. Hay que tener encuenta que main es esttico, con lo que dentro slo podremos utilizar campos y mtodosestticos, o bien campos y mtodos de objetos que creemos dentro del main.

1.4. Herencia e interfaces

1.4.1. Herencia

Cuando queremos que una clase herede de otra, se utiliza al declararla la palabra extendstras el nombre de la clase, para decir de qu clase se hereda. Para hacer que Pato heredede Animal:

class Pato extends Animal

Con esto automticamente Pato tomara todo lo que tuviese Animal (aparte, Pato puedeaadir sus caractersticas propias). Si Animal fuese una clase abstracta, Pato deberaimplementar los mtodos abstractos que tuviese.

1.4.2. Punteros this y super

El puntero this apunta al objeto en el que nos encontramos. Se utiliza normalmentecuando hay variables locales con el mismo nombre que variables de instancia de nuestro



objeto:public class MiClase{int i;public MiClase(int i){

this.i = i; // i de la clase = parametro i}

}

Tambin se suele utilizar para remarcar que se est accediendo a variables de instancia.

El puntero super se usa para acceder a un elemento en la clase padre. Si la clase Usuariotiene un mtodo getPermisos, y una subclase UsuarioAdministrador sobrescribe dichomtodo, podramos llamar al mtodo de la super-clase con:

public class UsuarioAdministrador extends Usuario {public List getPermisos() {

List permisos = super.getPermisos();permisos.add(PERMISO_ADMINISTRADOR);return permisos;

}}

Tambin podemos utilizar this y super como primera instruccin dentro de unconstructor para invocar a otros constructores. Dado que toda clase en Java hereda de otraclase, siempre ser necesario llamar a alguno de los constructores de la super-clase paraque se construya la parte relativa a ella. Por lo tanto, si al comienzo del constructor no seespecifica ninguna llamada a this o super, se considera que hay una llamada implcita alconstructor sin parmetros de la super-clase (super()). Es decir, los dos constructoressiguientes son equivalentes:

public Punto2D(int x, int y, String etiq) {// Existe una llamada implicita a super()

this.x = x;this.y = y;this.etiq = etiq;

}

public Punto2D(int x, int y, String etiq) {super();

this.x = x;this.y = y;this.etiq = etiq;

}

Pero es posible que la super-clase no disponga de un constructor sin parmetros. En esecaso, si no hacemos una llamada explcita a super nos dar un error de compilacin, yaque estar intentando llamar a un constructor inexistente de forma implcita. Es posibletambin, que aunque el constructor sin parmetros exista, nos interese llamar a otroconstructor a la hora de construir la parte relativa a la super-clase. Imaginemos porejemplo que la clase Punto2D anterior deriva de una clase PrimitivaGeometrica quealmacena, como informacin comn de todas las primitivas, una etiqueta de texto, y



ofrece un constructor que toma como parmetro dicha etiqueta. Podramos utilizar dichoconstructor desde la subclase de la siguiente forma:

public Punto2D(int x, int y, String etiq) {super(etiq);

this.x = x;this.y = y;

}

Tambin puede ocurrir que en lugar de querer llamar directamente al constructor de lasuper-clase nos interese basar nuestro constructor en otro de los constructores de nuestramisma clase. En tal caso llamaremos a this al comienzo de nuestro constructor,pasndole los parmetros correspondientes al constructor en el que queremos basarnos.Por ejemplo, podramos definir un constructor sin parmetros de nuestra clase punto, quese base en el constructor anterior (ms especfico) para crear un punto con una serie dedatos por defecto:

public Punto2D() {this(DEFAULT_X, DEFAULT_Y, DEFAULT_ETIQ);

}

Es importante recalcar que las llamadas a this o super deben ser siempre la primerainstruccin del constructor.

1.4.3. Interfaces y clases abstractas

Ya hemos visto cmo definir clases normales, y clases abstractas. Si queremos definir uninterfaz, se utiliza la palabra reservada interface, en lugar de class, y dentrodeclaramos (no implementamos), los mtodos que queremos que tenga la interfaz:

public interface MiInterfaz{

public void metodoInterfaz();public float otroMetodoInterfaz();

}

Despus, para que una clase implemente los mtodos de esta interfaz, se utiliza la palabrareservada implements tras el nombre de la clase:

public class UnaClase implements MiInterfaz{

public void metodoInterfaz(){


public float otroMetodoInterfaz(){


}

Notar que si en lugar de poner implements ponemos extends, en ese caso UnaClasedebera ser un interfaz, que heredara del interfaz MiInterfaz para definir ms



mtodos, pero no para implementar los que tiene la interfaz. Esto se utilizara para definirinterfaces partiendo de un interfaz base, para aadir ms mtodos a implementar.

Una clase puede heredar slo de otra nica clase, pero puede implementar cuantosinterfaces necesite:

public class UnaClase extends MiClaseimplements MiInterfaz, MiInterfaz2, MiInterfaz3

{...

}

Cuando una clase implementa una interfaz se est asegurando que dicha clase va a ofrecerlos mtodos definidos en la interfaz, es decir, que la clase al menos nos ofrece esa interfazpara acceder a ella. Cuando heredamos de una clase abstracta, heredamos todos loscampos y el comportamiento de la superclase, y adems deberemos definir algunosmtodos que no haban sido implementados en la superclase.

Desde el punto de vista del diseo, podemos ver la herencia como una relacin ES,mientras que la implementacin de una interfaz sera una relacin ACTA COMO.

1.5. Hilos

En este curso no vamos a profundizar en la programacin de hilos. Si bien lasaplicaciones en servidor funcionan sobre mltiples hilos, de su gestin ya se ocupan losservidores de aplicaciones, como se ver. Independientemente de esto, es positivoconocer el mecanismo de hilos y sobre todo, su sincronizacin.

Un hilo es un flujo de control dentro de un programa. Creando varios hilos podremosrealizar varias tareas simultneamente. Cada hilo tendr slo un contexto de ejecucin(contador de programa, pila de ejecucin). Es decir, a diferencia de los procesos UNIX,no tienen su propio espacio de memoria sino que acceden todos al mismo espacio dememoria comn, por lo que ser importante su sincronizacin cuando tengamos varioshilos accediendo a los mismos objetos.

1.5.1. Creacin de hilos

En Java los hilos estn encapsulados en la clase Thread. Para crear un hilo tenemos dosposibilidades: Heredar de Thread redefiniendo el mtodo run(). Crear una clase que implemente la interfaz Runnable que nos obliga a definir el

mtodo run().

En ambos casos debemos definir un mtodo run() que ser el que contenga el cdigo delhilo. Desde dentro de este mtodo podremos llamar a cualquier otro mtodo de cualquierobjeto, pero este mtodo run() ser el mtodo que se invoque cuando iniciemos laejecucin de un hilo. El hilo terminar su ejecucin cuando termine de ejecutarse este



mtodo run().

Para crear nuestro hilo mediante herencia haremos lo siguiente:

public class EjemploHilo extends Thread{

public void run()(){

// Cdigo del hilo}

}

Una vez definida la clase de nuestro hilo deberemos instanciarlo y ejecutarlo de lasiguiente forma:

Thread t = new EjemploHilo();t.start();

Al llamar al mtodo start del hilo, comenzar ejecutarse su mtodo run. Crear un hiloheredando de Thread tiene el problema de que al no haber herencia mltiple en Java, siheredamos de Thread no podremos heredar de ninguna otra clase, y por lo tanto un hilono podra heredar de ninguna otra clase.

Este problema desaparece si utilizamos la interfaz Runnable para crear el hilo, ya que unaclase puede implementar varios interfaces. Definiremos la clase que contenga el hilocomo se muestra a continuacin:

public class EjemploHilo implements Runnable{

public void run(){

// Cdigo del hilo}

}

Para instanciar y ejecutar un hilo de este tipo deberemos hacer lo siguiente:

Thread t = new Thread(new EjemploHilo());t.start();

Esto es as debido a que en este caso EjemploHilo no deriva de una clase Thread, por loque no se puede considerar un hilo, lo nico que estamos haciendo implementando lainterfaz es asegurar que vamos a tener definido el mtodo run(). Con esto lo queharemos ser proporcionar esta clase al constructor de la clase Thread, para que el objetoThread que creemos llame al mtodo run() de la clase que hemos definido al iniciarse laejecucin del hilo, ya que implementando la interfaz le aseguramos que esta funcinexiste.



1.5.2. Ciclo de vida y prioridades

Un hilo pasar por varios estados durante su ciclo de vida.Thread t = new Thread(this);

Una vez se ha instanciado el objeto del hilo, diremos que est en estado de Nuevo hilo.t.start();

Cuando invoquemos su mtodo start() el hilo pasar a ser un hilo vivo, comenzndosea ejecutar su mtodo run(). Una vez haya salido de este mtodo pasar a ser un hilomuerto.

La nica forma de parar un hilo es hacer que salga del mtodo run() de forma natural.Podremos conseguir esto haciendo que se cumpla una condicin de salida de run()(lgicamente, la condicin que se nos ocurra depender del tipo de programa que estemoshaciendo). Las funciones para parar, pausar y reanudar hilos estn desaprobadas en lasversiones actuales de Java.

Mientras el hilo est vivo, podr encontrarse en dos estados: Ejecutable y No ejecutable.El hilo pasar de Ejecutable a No ejecutable en los siguientes casos: Cuando se encuentre dormido por haberse llamado al mtodo sleep(), permanecer

No ejecutable hasta haber transcurrido el nmero de milisegundos especificados. Cuando se encuentre bloqueado en una llamada al mtodo wait() esperando que otro

hilo lo desbloquee llamando a notify() o notifyAll(). Veremos cmo utilizar estosmtodos ms adelante.

Cuando se encuentre bloqueado en una peticin de E/S, hasta que se complete laoperacin de E/S.

Ciclo de vida de los hilos

Lo nico que podremos saber es si un hilo se encuentra vivo o no, llamando a su mtodoisAlive().

Prioridades de los hilos

Adems, una propiedad importante de los hilos ser su prioridad. Mientras el hilo seencuentre vivo, el scheduler de la mquina virtual Java le asignar o lo sacar de la CPU,coordinando as el uso de la CPU por parte de todos los hilos activos basndose en suprioridad. Se puede forzar la salida de un hilo de la CPU llamando a su mtodo yield().Tambin se sacar un hilo de la CPU cuando un hilo de mayor prioridad se haga



Ejecutable, o cuando el tiempo que se le haya asignado expire.Para cambiar la prioridad de un hilo se utiliza el mtodo setPriority(), al quedeberemos proporcionar un valor de prioridad entre MIN_PRIORITY y MAX_PRIORITY(tenis constantes de prioridad disponibles dentro de la clase Thread, consultad el API deJava para ver qu valores de constantes hay).

1.5.3. Sincronizacin de hilos

Muchas veces los hilos debern trabajar de forma coordinada, por lo que es necesario unmecanismo de sincronizacin entre ellos.

Un primer mecanismo de comunicacin es la variable cerrojo incluida en todo objetoObject, que permitir evitar que ms de un hilo entre en la seccin crtica para un objetodeterminado. Los mtodos declarados como synchronized utilizan el cerrojo del objetoal que pertenecen evitando que ms de un hilo entre en ellos al mismo tiempo.

public synchronized void seccion_critica(){

// Cdigo seccin crtica}

Todos los mtodos synchronized de un mismo objeto (no clase, sino objeto de esaclase), comparten el mismo cerrojo, y es distinto al cerrojo de otros objetos (de la mismaclase, o de otras).Tambin podemos utilizar cualquier otro objeto para la sincronizacin dentro de nuestromtodo de la siguiente forma:

synchronized(objeto_con_cerrojo){// Cdigo seccin crtica

}

de esta forma sincronizaramos el cdigo que escribisemos dentro, con el cdigosynchronized del objeto objeto_con_cerrojo.Adems podemos hacer que un hilo quede bloqueado a la espera de que otro hilo lodesbloquee cuando suceda un determinado evento. Para bloquear un hilo usaremos lafuncin wait(), para lo cual el hilo que llama a esta funcin debe estar en posesin delmonitor, cosa que ocurre dentro de un mtodo synchronized, por lo que slo podremosbloquear a un proceso dentro de estos mtodos.

Para desbloquear a los hilos que haya bloqueados se utilizar notifyAll(), o bien notify()para desbloquear slo uno de ellos aleatoriamente. Para invocar estos mtodos ocurrir lomismo, el hilo deber estar en posesin del monitor.

Cuando un hilo queda bloqueado liberar el cerrojo para que otro hilo pueda entrar en la



seccin crtica del objeto y desbloquearlo.Por ltimo, puede ser necesario esperar a que un determinado hilo haya finalizado sutarea para continuar. Esto lo podremos hacer llamando al mtodo join() de dicho hilo,que nos bloquear hasta que el hilo haya finalizado.

1.6. Clases tiles

Cuando se programa con Java, se dispone de antemano de un conjunto de clases yaimplementadas. Estas clases (aparte de las que pueda hacer el usuario) forman parte delpropio lenguaje (lo que se conoce como API (Application Programming Interface) deJava).En esta seccin vamos a ver una serie de clases que conviene conocer ya que nos sern degran utilidad para realizar nuestros programas:

1.6.1. ObjectEsta es la clase base de todas las clases en Java, toda clase hereda en ltima instancia dela clase Object, por lo que los mtodos que ofrece estarn disponibles en cualquier objetoJava, sea de la clase que sea.

En Java es importante distinguir claramente entre lo que es una variable, y lo que es unobjeto. Las variables simplemente son referencias a objetos, mientras que los objetos sonlas entidades instanciadas en memoria que podrn ser manipulados mediante lasreferencias que tenemos a ellos (mediante variable que apunten a ellos) dentro de nuestroprograma. Cuando hacemos lo siguiente:

new MiClase()

Se est instanciando en memoria un nuevo objeto de clase MiClase y nos devuelve unareferencia a dicho objeto. Nosotros deberemos guardarnos dicha referencia en algunavariable con el fin de poder acceder al objeto creado desde nuestro programa:

MiClase mc = new MiClase();

Es importante declarar la referencia del tipo adecuado (en este caso tipo MiClase) paramanipular el objeto, ya que el tipo de la referencia ser el que indicar al compilador lasoperaciones que podremos realizar con dicho objeto. El tipo de esta referencia podr sertanto el mismo tipo del objeto al que vayamos a apuntar, o bien el de cualquier clase de laque herede o interfaz que implemente nuestro objeto. Por ejemplo, si MiClase se definede la siguiente forma:

public class MiClase extends Thread implements List {...

}

Podremos hacer referencia a ella de diferentes formas:



MiClase mc = new MiClase();Thread t = new MiClase();List l = new MiClase();Object o = new MiClase();

Esto es as ya que al heredar tanto de Thread como de Object, sabemos que el objetotendr todo lo que tienen estas clases ms lo que aada MiClase, por lo que podrcomportarse como cualquiera de las clases anteriores. Lo mismo ocurre al implementaruna interfaz, al forzar a que se implementen sus mtodos podremos hacer referencia alobjeto mediante la interfaz ya que sabemos que va a contener todos esos mtodos.Siempre vamos a poder hacer esta asignacin 'ascendente' a clases o interfaces de las quederiva nuestro objeto.Si hacemos referencia a un objeto MiClase mediante una referencia Object por ejemplo,slo podremos acceder a los mtodos de Object, aunque el objeto contenga mtodosadicionales definidos en MiClase. Si conocemos que nuestro objeto es de tipo MiClase, yqueremos poder utilizarlo como tal, podremos hacer una asignacin 'descendente'aplicando una conversin cast al tipo concreto de objeto:

Object o = new MiClase();...

MiClase mc = (MiClase) o;

Si resultase que nuestro objeto no es de la clase a la que hacemos cast, ni hereda de ella nila implementa, esta llamada resultar en un ClassCastException indicando que nopodemos hacer referencia a dicho objeto mediante esa interfaz debido a que el objeto nola cumple, y por lo tanto podrn no estar disponibles los mtodos que se definen en ella.

Una vez hemos visto la diferencia entre las variables (referencias) y objetos (entidades)vamos a ver como se har la asignacin y comparacin de objetos. Si hiciesemos losiguiente:

MiClase mc1 = new MiClase();MiClase mc2 = mc1;

Puesto que hemos dicho que las variables simplemente son referencias a objetos, laasignacin estar copiando una referencia, no el objeto. Es decir, tanto la variable mc1como mc2 apuntarn a un mismo objeto.Si lo que queremos es copiar un objeto, teniendo dos entidades independientes,deberemos invocar el mtodo clone del objeto a copiar:

MiClase mc2 = (MiClase)mc1.clone();

El mtodo clone es un mtodo de la clase Object que estar disponible para cualquierobjeto Java, y nos devuelve un Object genrico, ya que al ser un mtodo que puede servirpara cualquier objeto nos debe devolver la copia de este tipo. De l tendremos que haceruna conversin cast a la clase de la que se trate como hemos visto en el ejemplo. Al haceruna copia con clone se copiarn los valores de todas las variables de instancia, pero siestas variables son referencias a objetos slo se copiar la referencia, no el objeto. Es



decir, no se har una copia en profundidad. Si queremos hacer una copia en profundidaddeberemos sobrescribir el mtodo clone para hacer una copia de cada uno de estosobjetos. Para copiar objetos tambin podramos definir un constructor de copia, al que sele pase como parmetro el objeto original a copiar.Por otro lado, para la comparacin, si hacemos lo siguiente:

mc1 == mc2

Estaremos comparando referencias, por lo que estaremos viendo si las dos referenciasapuntan a un mismo objeto, y no si los objetos a los que apuntan son iguales. Para ver silos objetos son iguales, aunque sean entidades distintas, tenemos:

mc1.equals(mc2)

Este mtodo tambin es propio de la clase Object, y ser el que se utilice para compararinternamente los objetos. Para que funcione correctamente, este mtodo debern serredefinido en nuestras clases para indicar cuando se considera que dos objetos soniguales. Por ejemplo podemos tener una clase como la siguiente:

public class Punto2D {

public int x, y;

...

public boolean equals(Object o) {Punto2D p = (Punto2D)o;// Compara objeto this con objeto preturn (x == p.x && y == p.y);

}

Un ltimo mtodo interesante de la clase Object es toString. Este mtodo nos devuelveuna cadena (String) que representa dicho objeto. Por defecto nos dar un identificadordel objeto, pero nosotros podemos sobrescribirla en nuestras propias clases para quegenere la cadena que queramos. De esta manera podremos imprimir el objeto en forma decadena de texto, mostrandose los datos con el formato que nosotros les hayamos dado entoString. Por ejemplo, si tenemos una clase Punto2D, sera buena idea hacer que suconversin a cadena muestre las coordenadas (x,y) del punto:

public class Punto2D {

public int x,y;

...

public String toString() {String s = "(" + x + "," + y + ")";return s;

}}

1.6.2. Properties



Esta clase es un subtipo de Hastable, que se encarga de almacenar una serie depropiedades asociando un valor a cada una de ellas. Estas propiedades las podremosutilizar para registrar la configuracin de nuestra aplicacin. Adems esta clase nospermite cargar o almacenar esta informacin en algn dispositivo, como puede ser endisco, de forma que sea persistente.

Puesto que hereda de Hashtable, podremos utilizar sus mtodos, pero tambin aportamtodos propios para aadir propiedades:

Object setProperty(Object clave, Object valor)

Equivalente al mtodo put.Object getProperty(Object clave)

Equivalente al mtodo get.Object getProperty(Object clave, Object default)

Esta variante del mtodo resulta til cuando queremos que determinada propiedaddevuelva algn valor por defecto si todava no se le ha asignado ningn valor.

Adems, como hemos dicho anteriormente, para hacer persistentes estas propiedades denuestra aplicacin, se proporcionan mtodos para almacenarlas o leerlas de algndispositivo de E/S:

void load(InputStream entrada)

Lee las propiedades del flujo de entrada proporcionado. Este flujo puede por ejemploreferirse a un fichero del que se leern los datos.

void store(OutputStream salida, String cabecera)

Almacena las informacin de las propiedades escribiendolas en el flujo de salidaespecificado. Este flujo puede por ejemplo referirse a un fichero en disco, en el que seguardar nuestro conjunto de propiedades, pudiendo especificar una cadena que se pondrcomo cabecera en el fichero, y que nos permite aadir algn comentario sobre dichofichero.

1.6.3. System

Esta clase nos ofrece una serie de mtodos y campos tiles del sistema. Esta clase no sedebe instanciar, todos estos mtodos y campos son estticos.

Podemos encontrar los objetos que encapsulan la entrada, salida y salida de errorestndar, as como mtodos para redireccionarlas, que veremos con ms detalle en el temade entrada/salida.

Tambin nos permite acceder al gestor de seguridad instalado, como veremos en el temasobre seguridad.



Otros mtodos tiles que encontramos son:void exit(int estado)

Finaliza la ejecucin de la aplicacin, devolviendo un cdigo de estado. Normalmente elcdigo 0 significa que ha salido de forma normal, mientras que con otros cdigosindicaremos que se ha producido algn error.

void gc()

Fuerza una llamada al colector de basura para limpiar la memoria. Esta es una operacincostosa. Normalmente no lo llamaremos explicitamente, sino que dejaremos que Java loinvoque cuando sea necesario.

long currentTimeMillis()

Nos devuelve el tiempo medido en el nmero de milisegundos transcurridos desde el 1 deEnero de 1970 a las 0:00.

void arraycopy(Object fuente, int pos_fuente,Object destino, int pos_dest, int n)

Copia n elementos del array fuente, desde la posicin pos_fuente, al array destino a partirde la posicin pos_dest.

Properties getProperties()

Devuelve un objeto Properties con las propiedades del sistema. En estas propiedadespodremos encontrar la siguiente informacin:Clave Contenido

file.separator Separador entre directorios en la ruta de losficheros. Por ejemplo "/" en UNIX.

java.class.path Classpath de Javajava.class.version Versin de las clases de Javajava.home Directorio donde est instalado Javajava.vendor Empresa desarrolladora de la implementacin

de la plataforma Java instalada

java.vendor.url URL de la empresajava.version Versin de Javaline.separator Separador de fin de lneas utilizado

os.arch Arquitectura del sistema operativo

os.name Nombre del sistema operativo

os.version Versin del sistema operativo



path.separator Separador entre los distintos elementos de unavariable de entorno tipo PATH. Por ejemplo ":"

user.dir Directorio actual

user.home Directorio de inicio del usuario actual

user.name Nombre de la cuenta del usuario actual

1.6.4. Runtime

Toda aplicacin Java tiene una instancia de la clase Runtime que se encargar de hacer deinterfaz con el entorno en el que se est ejecutando. Para obtener este objeto debemosutilizar el siguiente mtodo esttico:

Runtime rt = Runtime.getRuntime();

Una de las operaciones que podremos realizar con este objeto, ser ejecutar comandoscomo si nos encontrsemos en la lnea de comandos del sistema operativo. Para elloutilizaremos el siguiente mtodo:

rt.exec(comando);

De esta forma podremos invocar programas externos desde nuestra aplicacin Java.

1.6.5. Math

La clase Math nos ser de gran utilidad cuando necesitemos realizar operacionesmatemticas. Esta clase no necesita ser instanciada, ya que todos sus mtodos sonestticos. Entre estos mtodos podremos encontrar todas las operaciones matemticasbsicas que podamos necesitar, como logaritmos, exponenciales, funcionestrigonomtricas, generacin de nmeros aleatorios, conversin entre grados y radianes,etc. Adems nos ofrece las constantes de los nmeros PI y E.

1.6.6. Otras clases

Si miramos dentro del paquete java.util, podremos encontrar una serie de clases quenos podrn resultar tiles para determinadas aplicaciones.

Entre ellas tenemos la clase Locale que almacena informacin sobre una determinadaregin del mundo (pas e idioma), y que podr ser utilizada para internacionalizar nuestraaplicacin de forma sencilla. Una clase relacionada con esta ltima es ResourceBundle,con la que podemos definir las cadenas de texto de nuestra aplicacin en una serie deficheros de propiedades (uno para cada idioma). Por ejemplo, podramos tener dosficheros Textos_en.properties y Textos_es.properties con los textos en ingls y encastellano respectivamente. Si abrimos el bundle de nombre Textos, se utilizar el localede nuestro sistema para cargar los textos del fichero que corresponda. Tambin



encontramos otras clases relacionadas con Locale, como por ejemplo Currency coninformacin monetaria adaptada a nuestra zona, clases que nos permiten formatearnmeros o fechas (NumberFormat y DateFormat respectivamente) segn lasconvenciones de nuestra zona, o bien de forma personalizada, y la clase Calendar, quenos ser til cuando trabajemos con fechas y horas, para realizar operaciones con fechas,compararlas, o acceder a sus campos por separado.

1.7. Estructuras de datos

En nuestras aplicaciones normalmente trabajamos con diversos conjuntos de atributos queson siempre utilizados de forma conjunta (por ejemplo, los datos de un punto en un mapa:coordenada x, coordenada y, descripcion). Estos datos se debern ir pasando entre lasdiferentes capas de la aplicacin.

Podemos utilizar el patrn Transfer Object para encapsular estos datos en un objeto, ytratarlos as de forma eficiente. Este objeto tendr como campos los datos que encapsula.En el caso de que estos campos sean privados, nos deber proporcionar mtodos paraacceder a ellos. Estos mtodos son conocidos como getters y setters, y nos permitirnconsultar o modificar su valor respectivamente. Una vez escritos los campos privados,Eclipse puede generar los getters y setters de forma automtica pinchando sobre el cdigofuente con el botn derecho del ratn y seleccionando la opcin Source > GenerateGetters and Setters.... Por ejemplo, si creamos una clase como la siguiente:

public class Punto2D {private int x;private int y;private String descripcion;

}

Al generar los getters y setters con Eclipse aparecern los siguientes mtodos:public String getDescripcion() {

return descripcion;}public void setDescripcion(String descripcion) {

this.descripcion = descripcion;}public int getX() {

return x;}public void setX(int x) {

this.x = x;}public int getY() {

return y;}public void setY(int y) {

this.y = y;}

Con Eclipse tambin podremos generar diferentes tipos de constructores para estosobjetos. Por ejemplo, con la opcin Source > Generate Constructor Using Fields...generar un constructor que tomar como entrada los campos del objeto que le



indiquemos.

1.7.1. BeanUtils

Idealmente un mismo campo slo estar en una clase, por ejemplo, los camposcorrespondientes a los datos personales de un cliente no tienen por qu repetirse una yotra vez en distintas clases. Sin embargo cuando construimos un Transfer Object esbastante comn que copiemos datos entre campos que tienen una correspondencia exacta.Por ejemplo, tenemos el siguiente Transfer Object que es muy similar al Punto2D:

public class Punto3D {private int x;private int y;private int z;private String descripcion;/* ...y los getters y setters para los cuatro campos */}

Si necesitamos copiar los datos de Punto3D a Punto2D, tres de los campos coinciden.(Esta operacin sera una proyeccin del punto sobre el plano XY). Manualmentenecesitaramos hacer:

punto2D.setX(punto3D.getX());punto2D.setY(punto3D.getY());punto2D.setDescripcion(punto3D.getDescripcion());

La clase BeanUtils, perteneciente a la biblioteca commons-beanutils de Apache, nosproporciona el mtodo copyProperties(objetoDestino, objetoOrigen) que permitehacer lo mismo en una sola lnea. Se trata de un wrapper que hace uso de la API deReflection. Esta API nos permite, entre otras cosas, examinar modificadores, tipos ycampos de un objeto en tiempo de ejecucin.

BeanUtils.copyProperties(punto2D, punto3D);

Lo que importa es que los getters y setters que se vayan a copiar coincidan en el tipo y ensu nombre a partir del prefijo get y set. Aparte de incluir la bibliotecacommons-beanutils tambin se requiere incluir commons-logging, de la cul hace usoel mtodo copyProperties(...).



2. Ejercicios de Introduccin al lenguaje Java

2.1. Uso de interfaces (1 punto)Tenemos una aplicacin para gestionar nuestra coleccin de DVDs, en la que podemosaadir pelculas a la coleccin, eliminarlas, o consultar la lista de todas las pelculas queposeemos. En esta aplicacin tenemos una clase FilePeliculaDAO que nos ofrece lossiguientes mtodos:

public void addPelicula(PeliculaTO p);public void delPelicula(int idPelicula);public List getAllPeliculas();

Esta clase nos permitir acceder a los datos de nuestra coleccin almacenados en unfichero en disco. Siempre que en algn lugar de la aplicacin se haga un acceso a losdatos se utilizar esta clase. Por ejemplo, si introducimos los datos de una nueva pelculaen un formulario y pulsamos el botn para aadir la pelcula, se invocara un cdigo comoel siguiente:

FilePeliculaDAO fpdao = GestorDAO.getPeliculaDAO();fpdao.addPelicula(pelicula);

La clase auxiliar GestorDAO tiene un mtodo esttico que nos permitir obtener unainstancia de los objetos de acceso a datos desde cualquier lugar de nuestro cdigo. En elcaso anterior este mtodo sera algo as como:

public static FilePeliculaDAO getPeliculaDAO() {return new FilePeliculaDAO();

}

Como la aplicacin crece de tamao decidimos pasar a almacenar los datos en una BD enlugar de hacerlo en un fichero. Para ello creamos una nueva clase JDBCPeliculaDAO, quedeber ofrecer las mismas operaciones que la clase anterior. Qu cambios tendremos quehacer en nuestro cdigo para que nuestra aplicacin pase a almacenar los datos en unaBD? (Imaginemos que estamos accediendo a FilePeliculaDAO desde 20 puntos distintosde nuestra aplicacin).En una segunda versin de nuestra aplicacin tenemos definida una interfazIPeliculaDAO con los mismos mtodos que comentados anteriormente. Tendremostambin la clase FilePeliculaDAO que en este caso implementa la interfazIPeliculaDAO. En este caso el acceso a los datos desde el cdigo de nuestra aplicacin sehace de la siguiente forma:

IPeliculaDAO pdao = GestorDAO.getPeliculaDAO();pdao.addPelicula(pelicula);

El GestorDAO ahora ser como se muestra a continuacin:public static IPeliculaDAO getPeliculaDAO() {



return new FilePeliculaDAO();}

Qu cambios tendremos que realizar en este segundo caso para pasar a utilizar una BD?Por lo tanto, qu versin consideras ms adecuada?

2.2. Refactorizacin (1 punto)En las plantillas de la sesin podemos encontrar un proyecto lja-filmoteca en el quetenemos implementada la primera versin de la aplicacin anterior. Realiza unarefactorizacin del cdigo para facilitar los cambios en el acceso a datos (deber quedarcomo la segunda versin comentada en el ejercicio anterior).

AyudaResultar til el men Refactor de Eclipse. En l podemos encontrar opciones que nos permitanhacer los cambios necesarios de forma automtica.

Una vez hechos los cambios aadir el nuevo DAO JDBCPeliculaDAO y probar a cambiarde un DAO a otro (si se ha hecho bien slo har falta modificar una lnea de cdigo). Nohar falta implementar las operaciones de los DAO. Bastar con imprimir mensajes en laconsola que nos digan lo que estara haciendo cada operacin.

2.3. Documentacin (0.5 puntos)El proyecto anterior tiene una serie de anotaciones en los comentarios que nos permitengenerar documentacin Javadoc de forma automtica desde Eclipse. Observa lasanotaciones puestas en los comentarios, las marcas @param, @return, @deprecated...

Genera la documentacin de este proyecto (men Project > Generate Javadoc...) en unasubcarpeta doc dentro del proyecto actual. Eclipse nos preguntar si queremos establecereste directorio como el directorio de documentacin de nuestro proyecto, a lo queresponderemos afirmativamente.

Aade comentarios Javadoc a las nuevas clases creadas en el ejercicio anterior y generanuevamente la documentacin. Prueba ahora a escribir cdigo que utilice alguna de lasclases de nuestro proyecto, usando la opcin de autocompletar de Eclipse. Veremos quejunto a cada miembro de la clase nos aparecer su documentacin.

2.4. Centro cultural (1 punto)Un centro cultural se dedica al prstamo de dos tipos de materiales de prstamo: discos ylibros. Para los dos se guarda informacin general, como su cdigo identificativo, el ttuloy el autor. En el caso de los libros, almacenamos tambin su nmero de pginas y uncaptulo de muestra, y para los discos el nombre de la discogrfica.



Tambin podemos encontrar una serie de documentos con las normas e informacin sobreel centro de los que guardamos su ttulo, fecha de publicacin y texto. Tanto estosdocumentos como los libros se podrn imprimir (en el caso de los libros se imprimir elttulo, los autores, y el captulo de muestra, mientras que de los documentos se imprimirsu ttulo, su fecha de publicacin y su texto).Escribe la estructura de clases que consideres adecuada para representar esta informacinen un nuevo proyecto lja-centrocultural. Utiliza las facilidades que ofrece Eclipsepara generar de forma automtica los constructores y getters y setters necesarios.

2.5. Copia de propiedades con BeanUtils (0.5 puntos)En las plantillas de la sesin contamos con un proyecto llamado lja-copyproperties enel que hay una clase principal que crea dos objetos: uno de clase PeliculaTO y otro declase Mpeg4fileTO. Se trata de dos transfer objects muy similares que comparten varioscampos.

Copia todos los campos que puedas desde PeliculaTO hacia Mpeg4fileTO,sobreescribiendo los campos que se pueda y dejando como estn los campos que nocoincidan.

Ahora utiliza el mtodo BeanUtils.copyProperties(dest,orig) para hacer lo mismoen una sola lnea. Tendrs que incluir las bibliotecas correspondientes, que se encuentranen la carpeta lib.

Observa el resultado para ver si se han copiado bien todos los campos que esperabas.Encuentras algn fallo en la copia de la fecha de estreno? Corrgelo y comprueba que secopia correctamente.



3. Colecciones de datos

La plataforma Java nos proporciona un amplio conjunto de clases dentro del que podemosencontrar tipos de datos que nos resultarn muy tiles para realizar la programacin deaplicaciones en Java. Estos tipos de datos nos ayudarn a generar cdigo ms limpio deuna forma sencilla.

Se proporcionan una serie de operadores para acceder a los elementos de estos tipos dedatos. Decimos que dichos operadores son polimrficos, ya que un mismo operador sepuede emplear para acceder a distintos tipos de datos. Por ejemplo, un operador addutilizado para aadir un elemento, podr ser empleado tanto si estamos trabajando conuna lista enlazada, con un array, o con un conjunto por ejemplo.Este polimorfismo se debe a la definicin de interfaces que deben implementar losdistintos tipos de datos. Siempre que el tipo de datos contenga una coleccin deelementos, implementar la interfaz Collection. Esta interfaz proporciona mtodos paraacceder a la coleccin de elementos, que podremos utilizar para cualquier tipo de datosque sea una coleccin de elementos, independientemente de su implementacin concreta.

Podemos encontrar los siguientes elementos dentro del marco de colecciones de Java: Interfaces para distintos tipos de datos: Definirn las operaciones que se pueden

realizar con dichos tipos de datos. Podemos encontrar aqu la interfaz para cualquiercoleccin de datos, y de manera ms concreta para listas (secuencias) de datos,conjuntos, etc.

Implementaciones de tipos de datos reutilizables: Son clases que implementan tiposde datos concretos que podremos utilizar para nuestras aplicaciones, implementandoalgunas de las interfaces anteriores para acceder a los elementos de dicho tipo dedatos. Por ejemplo, dentro de las listas de elementos, podremos encontrar distintasimplementaciones de la lista como puede ser listas enlazadas, o bien arrays decapacidad variable, pero al implementar la misma interfaz podremos acceder a suselementos mediante las mismas operaciones (polimorfismo).

Algoritmos para trabajar con dichos tipos de datos, que nos permitan realizar unaordenacin de los elementos de una lista, o diversos tipos de bsqueda de undeterminado elemento por ejemplo.

3.1. Colecciones

Las colecciones representan grupos de objetos, denominados elementos. Podemosencontrar diversos tipos de colecciones, segn si sus elementos estn ordenados, o sipermitimos repeticin de elementos o no.

Es el tipo ms genrico en cuanto a que se refiere a cualquier tipo que contenga un grupode elementos. Viene definido por la interfaz Collection, de la cual heredar cada



subtipo especfico. En esta interfaz encontramos una serie de mtodos que nos servirnpara acceder a los elementos de cualquier coleccin de datos, sea del tipo que sea. Estosmtodos generales son:

boolean add(Object o)

Aade un elemento (objeto) a la coleccin. Nos devuelve true si tras aadir el elemento lacoleccin ha cambiado, es decir, el elemento se ha aadido correctamente, o false en casocontrario.

void clear()

Elimina todos los elementos de la coleccin.boolean contains(Object o)

Indica si la coleccin contiene el elemento (objeto) indicado.boolean isEmpty()

Indica si la coleccin est vaca (no tiene ningn elemento).Iterator iterator()

Proporciona un iterador para acceder a los elementos de la coleccin.boolean remove(Object o)

Elimina un determinado elemento (objeto) de la coleccin, devolviendo true si dichoelemento estaba contenido en la coleccin, y false en caso contrario.

int size()

Nos devuelve el nmero de elementos que contiene la coleccin.Object [] toArray()

Nos devuelve la coleccin de elementos como un array de objetos. Si sabemos deantemano que los objetos de la coleccin son todos de un determinado tipo (como porejemplo de tipo String) podremos obtenerlos en un array del tipo adecuado, en lugar deusar un array de objetos genricos. En este caso NO podremos hacer una conversin castdescendente de array de objetos a array de un tipo ms concreto, ya que el array se habrinstanciado simplemente como array de objetos:

// Esto no se puede hacer!!!String [] cadenas = (String []) coleccion.toArray();

Lo que si podemos hacer es instanciar nosotros un array del tipo adecuado y hacer unaconversin cast ascendente (de tipo concreto a array de objetos), y utilizar el siguientemtodo:

String [] cadenas = new String[coleccion.size()];coleccion.toArray(cadenas); // Esto si que funcionar



Esta interfaz es muy genrica, y por lo tanto no hay ningn tipo de datos que laimplemente directamente, sino que implementarn subtipos de ellas. A continuacinveremos los subtipos ms comunes.

3.1.1. Listas de elementos

Este tipo de coleccin se refiere a listas en las que los elementos de la coleccin tienen unorden, existe una secuencia de elementos. En ellas cada elemento estar en unadeterminada posicin (ndice) de la lista.Las listas vienen definidas en la interfaz List, que adems de los mtodos generales delas colecciones, nos ofrece los siguientes para trabajar con los ndices:

void add(int indice, Object obj)

Inserta un elemento (objeto) en la posicin de la lista dada por el ndice indicado.Object get(int indice)

Obtiene el elemento (objeto) de la posicin de la lista dada por el ndice indicado.int indexOf(Object obj)

Nos dice cual es el ndice de dicho elemento (objeto) dentro de la lista. Nos devuelve -1 siel objeto no se encuentra en la lista.

Object remove(int indice)

Elimina el elemento que se encuentre en la posicin de la lista indicada mediante dichondice, devolvindonos el objeto eliminado.

Object set(int indice, Object obj)

Establece el elemento de la lista en la posicin dada por el ndice al objeto indicado,sobrescribiendo el objeto que hubiera anteriormente en dicha posicin. Nos devolver elelemento que haba previamente en dicha posicin.

Podemos encontrar diferentes implementaciones de listas de elementos en Java:

ArrayList

Implementa una lista de elementos mediante un array de tamao variable. Conforme seaaden elementos el tamao del array ir creciendo si es necesario. El array tendr unacapacidad inicial, y en el momento en el que se rebase dicha capacidad, se aumentar eltamao del array.

Las operaciones de aadir un elemento al final del array (add), y de establecer u obtenerel elemento en una determinada posicin (get/set) tienen un coste temporal constante. Lasinserciones y borrados tienen un coste lineal O(n), donde n es el nmero de elementos delarray.



Hemos de destacar que la implementacin de ArrayList no est sincronizada, es decir, simltiples hilos acceden a un mismo ArrayList concurrentemente podriamos tenerproblemas en la consistencia de los datos. Por lo tanto, deberemos tener en cuenta cuandousemos este tipo de datos que debemos controlar la concurrencia de acceso. Tambinpodemos hacer que sea sincronizado como veremos ms adelante.

Vector

El Vector es una implementacin similar al ArrayList, con la diferencia de que elVector si que est sincronizado. Este es un caso especial, ya que la implementacinbsica del resto de tipos de datos no est sincronizada.

Esta clase existe desde las primeras versiones de Java, en las que no exista el marco delas colecciones descrito anteriormente. En las ltimas versiones el Vector se haacomodado a este marco implementando la interfaz List.

Sin embargo, si trabajamos con versiones previas de JDK, hemos de tener en cuenta quedicha interfaz no exista, y por lo tanto esta versin previa del vector no contar con losmtodos definidos en ella. Los mtodos propios del vector para acceder a su contenido,que han existido desde las primeras versiones, son los siguientes:

void addElement(Object obj)

Aade un elemento al final del vector.Object elementAt(int indice)

Devuelve el elemento de la posicin del vector indicada por el ndice.void insertElementAt(Object obj, int indice)

Inserta un elemento en la posicin indicada.boolean removeElement(Object obj)

Elimina el elemento indicado del vector, devolviendo true si dicho elemento estabacontenido en el vector, y false en caso contrario.

void removeElementAt(int indice)

Elimina el elemento de la posicin indicada en el ndice.void setElementAt(Object obj, int indice)

Sobrescribe el elemento de la posicin indicada con el objeto especificado.int size()

Devuelve el nmero de elementos del vector.

Por lo tanto, si programamos para versiones antiguas de la mquina virtual Java, serrecomendable utilizar estos mtodos para asegurarnos de que nuestro programa funcione.Esto ser importante en la programacin de Applets, ya que la mquina virtual incluida en



muchos navegadores corresponde a versiones antiguas.

Sobre el vector se construye el tipo pila (Stack), que apoyndose en el tipo vector ofrecemtodos para trabajar con dicho vector como si se tratase de una pila, apilando ydesapilando elementos (operaciones push y pop respectivamente). La clase Stack heredade Vector, por lo que en realidad ser un vector que ofrece mtodos adicionales paratrabajar con l como si fuese una pila.LinkedList

En este caso se implementa la lista mediante una lista doblemente enlazada. Por lo tanto,el coste temporal de las operaciones ser el de este tipo de listas. Cuando realicemosinserciones, borrados o lecturas en los extremos inicial o final de la lista el tiempo serconstante, mientras que para cualquier operacin en la que necesitemos localizar undeterminado ndice dentro de la lista deberemos recorrer la lista de inicio a fin, por lo queel coste ser lineal con el tamao de la lista O(n), siendo n el tamao de la lista.Para aprovechar las ventajas que tenemos en el coste temporal al trabajar con losextremos de la lista, se proporcionan mtodos propios para acceder a ellos en tiempoconstante:

void addFirst(Object obj) / void addLast(Object obj)

Aade el objeto indicado al principio / final de la lista respectivamente.Object getFirst() / Object getLast()

Obtiene el primer / ltimo objeto de la lista respectivamente.Object removeFirst() / Object removeLast()

Extrae el primer / ltimo elemento de la lista respectivamente, devolvindonos dichoobjeto y eliminndolo de la lista.Hemos de destacar que estos mtodos nos permitirn trabajar con la lista como si setratase de una pila o de una cola. En el caso de la pila realizaremos la insercin y laextraccin de elementos por el mismo extremo, mientras que para la cola insertaremospor un extremo y extraeremos por el otro.

3.1.2. ConjuntosLos conjuntos son grupos de elementos en los que no encontramos ningn elementorepetido. Consideramos que un elemento est repetido si tenemos dos objetos o1 y o2iguales, comparandolos mediante el operador o1.equals(o2). De esta forma, si el objeto ainsertar en el conjunto estuviese repetido, no nos dejar insertarlo. Recordemos que elmtodo add devolva un valor booleano, que servir para este caso, devolviendonos truesi el elemento a aadir no estaba en el conjunto y ha sido aadido, o false si el elementoya se encontraba dentro del conjunto. Un conjunto podr contener a lo sumo un elementonull.



Los conjuntos se definen en la interfaz Set, a partir de la cul se construyen diferentesimplementaciones:

HashSetLos objetos se almacenan en una tabla de dispersin (hash). El coste de las operacionesbsicas (insercin, borrado, bsqueda) se realizan en tiempo constante siempre que loselementos se hayan dispersado de forma adecuada. La iteracin a travs de sus elementoses ms costosa, ya que necesitar recorrer todas las entradas de la tabla de dispersin, loque har que el coste est en funcin tanto del nmero de elementos insertados en elconjunto como del nmero de entradas de la tabla. El orden de iteracin puede diferir delorden en el que se insertaron los elementos.

LinkedHashSetEs similar a la anterior pero la tabla de dispersin es doblemente enlazada. Los elementosque se inserten tendrn enlaces entre ellos. Por lo tanto, las operaciones bsicas seguirnteniendo coste constante, con la carga adicional que supone tener que gestionar losenlaces. Sin embargo habr una mejora en la iteracin, ya que al establecerse enlacesentre los elementos no tendremos que recorrer todas las entradas de la tabla, el coste sloestar en funcin del nmero de elementos insertados. En este caso, al haber enlaces entrelos elementos, estos enlaces definirn el orden en el que se insertaron en el conjunto, porlo que el orden de iteracin ser el mismo orden en el que se insertaron.

TreeSetUtiliza un rbol para el almacenamiento de los elementos. Por lo tanto, el coste pararealizar las operaciones bsicas ser logartmico con el nmero de elementos que tenga elconjunto O(log n).

3.1.3. Mapas

Aunque muchas veces se hable de los mapas como una coleccin, en realidad no lo son,ya que no heredan de la interfaz Collection.

Los mapas se definen en la interfaz Map. Un mapa es un objeto que relaciona una clave(key) con un valor. Contendr un conjunto de claves, y a cada clave se le asociar undeterminado valor. En versiones anteriores este mapeado entre claves y valores lo haca laclase Dictionary, que ha quedado obsoleta. Tanto la clave como el valor puede sercualquier objeto.Los mtodos bsicos para trabajar con estos elementos son los siguientes:

Object get(Object clave)

Nos devuelve el valor asociado a la clave indicadaObject put(Object clave, Object valor)


39Copyright 2012-201

lenguaje java avanzado

Documents