-
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
Lenguaje Java Avanzado
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
Lenguaje Java Avanzado
3Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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),
Lenguaje Java Avanzado
4Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
5Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
6Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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{...
}
Lenguaje Java Avanzado
7Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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){
... // Cdigo del mtodo}
Lenguaje Java Avanzado
8Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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...
Lenguaje Java Avanzado
9Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
10Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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:
Lenguaje Java Avanzado
11Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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{
Lenguaje Java Avanzado
12Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
...
}
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:
Lenguaje Java Avanzado
13Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
// 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:
Lenguaje Java Avanzado
14Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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");
Lenguaje Java Avanzado
15Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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){
... // Cdigo del mtodo}
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
Lenguaje Java Avanzado
16Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
17Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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(){
... // Cdigo del mtodo}
public float otroMetodoInterfaz(){
... // Cdigo del mtodo}
}
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
Lenguaje Java Avanzado
18Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
19Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
20Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
21Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
22Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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:
Lenguaje Java Avanzado
23Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
24Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
25Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
26Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
27Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
28Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
29Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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(...).
Lenguaje Java Avanzado
30Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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() {
Lenguaje Java Avanzado
31Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
32Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
33Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
34Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
35Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
36Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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
Lenguaje Java Avanzado
37Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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.
Lenguaje Java Avanzado
38Copyright 2012-2013 Dept. Ciencia de la Computacin e IA All
rights reserved.
-
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)
Lenguaje Java Avanzado
39Copyright 2012-201