Desarrollo de Proyectos Informáticos con Tecnología Java

269 Pages·2012·4.33 MB·Spanish

2
Esta obra de ´Oscar Belmonte et al. est´a bajo una licencia Creative
Commons Reconocimiento-NoComercial-CompartirIgual 3.0 Unported
´
Indice general
1. Introducci´on 13
1.1. Origen del lenguaje de programaci´on Java . . . . . . . . . . . . . 13
1.2. Caracter´ıstica de Java . . . . . . . . . . . . . . . . . . . . . . . . 14
1.3. El entorno de desarrollo integrado Eclipse . . . . . . . . . . . . . 15
1.3.1. Principales caracter´ısticas del entorno de desarrollo Eclipse 16
1.3.2. Descarga e instalaci´on de Eclipse . . . . . . . . . . . . . . 16
1.3.3. Configurando el aspecto de Eclipse: Perspectivas y Vistas 16
1.3.4. El primer ejemplo . . . . . . . . . . . . . . . . . . . . . . 18
1.4. Herramientas de desarrollo. . . . . . . . . . . . . . . . . . . . . . 21
1.4.1. An˜adiendo nueva funcionalidad a Eclipse: los plug-ins . . 22
2. Clases 23
2.1. Definici´on de una clase . . . . . . . . . . . . . . . . . . . . . . . . 24
2.2. Miembros de una clase . . . . . . . . . . . . . . . . . . . . . . . . 25
2.2.1. Atributos de una clase . . . . . . . . . . . . . . . . . . . . 25
2.2.2. M´etodos de una clase. . . . . . . . . . . . . . . . . . . . . 26
2.2.3. Constructores. . . . . . . . . . . . . . . . . . . . . . . . . 28
2.2.4. Sobrecarga de m´etodos y constructores. . . . . . . . . . . 32
2.3. Tipos de datos en Java. . . . . . . . . . . . . . . . . . . . . . . . 33
2.3.1. Arrays de datos en Java. . . . . . . . . . . . . . . . . . . . 34
2.4. Estructuras de control. . . . . . . . . . . . . . . . . . . . . . . . . 36
2.4.1. Estructuras de control de repetici´on. . . . . . . . . . . . . 37
2.4.2. Estructuras de control de selecci´on.. . . . . . . . . . . . . 39
2.5. Modificadores de acceso. . . . . . . . . . . . . . . . . . . . . . . . 40
2.6. Modificadores static y final. . . . . . . . . . . . . . . . . . . . 42
2.7. El recolector de basura. . . . . . . . . . . . . . . . . . . . . . . . 43
2.8. Finalizaci´on. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.9. Comentarios. Comentarios de documentaci´on. . . . . . . . . . . . 45
3. Herencia e Interfaces 51
3.1. Herencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2. Extensi´on de una clase. . . . . . . . . . . . . . . . . . . . . . . . 52
3.2.1. Sobrescribir atributos. . . . . . . . . . . . . . . . . . . . . 54
3.2.2. Sobrescribir m´etodos. . . . . . . . . . . . . . . . . . . . . 56
3.2.3. La palabra reservada super.. . . . . . . . . . . . . . . . . 59
3.2.4. El constructor por defecto y la clase Object. . . . . . . . 59
3.2.5. El operador instanceof. . . . . . . . . . . . . . . . . . . 60
3.2.6. El modificador final. . . . . . . . . . . . . . . . . . . . . 61
3
4 ´INDICE GENERAL
3.2.7. M´etodos static. . . . . . . . . . . . . . . . . . . . . . . . 62
3.3. Clases abstractas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.4. Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.5. Enumeraciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
3.6. Paquetes en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.7. Clases e interface anidados . . . . . . . . . . . . . . . . . . . . 71
4. Subversion 75
4.1. ¿Qu´e es un sistema de control de versiones? . . . . . . . . . . . . 76
4.2. Principales caracter´ısticas de Subversion . . . . . . . . . . . . . . 76
4.3. Creaci´on de un repositorio . . . . . . . . . . . . . . . . . . . . . . 77
4.4. Trabajo con repositorios . . . . . . . . . . . . . . . . . . . . . . . 78
4.4.1. Obteniendo informaci´on del repositorio . . . . . . . . . . 82
4.5. Integraci´on con Eclipse . . . . . . . . . . . . . . . . . . . . . . . . 84
5. Excepciones 87
5.1. ¿Qu´e es una excepci´on? . . . . . . . . . . . . . . . . . . . . . . . 87
5.1.1. Tipos de excepciones . . . . . . . . . . . . . . . . . . . . . 88
5.2. C´omo se gestiona una excepci´on . . . . . . . . . . . . . . . . . . 88
5.3. Creaci´on de excepciones propias. . . . . . . . . . . . . . . . . . . 91
6. Pruebas unitarias con JUnit 93
6.1. ¿Qu´e son las pruebas unitarias? . . . . . . . . . . . . . . . . . . . 94
6.1.1. Principios FIRST para el disen˜o de pruebas unitarias . . 94
6.2. Pruebas unitarias con JUnit . . . . . . . . . . . . . . . . . . . . . 95
6.2.1. Creaci´on de clases de prueba . . . . . . . . . . . . . . . . 95
6.2.2. La anotaci´on @Test . . . . . . . . . . . . . . . . . . . . . 96
6.2.3. Las anotaciones @Before y @After . . . . . . . . . . . . . 98
6.2.4. Las anotaciones @BeforeClass y @AfterClass . . . . . . 99
6.2.5. Pruebas con bater´ıa de datos de entrada . . . . . . . . . . 100
6.2.6. Ejecutar varias clases de prueba. Test Suites . . . . . . . 101
6.3. Cobertura de las pruebas . . . . . . . . . . . . . . . . . . . . . . 102
6.3.1. EclEmma y su plug-in para Eclipse . . . . . . . . . . . . . 103
7. Entrada y Salida 105
7.1. Flujos (Streams) . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.2. Flujos de bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
7.3. Flujos de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . 108
7.4. Conexi´on entre flujos de bytes y de caracteres . . . . . . . . . . . 109
7.5. El sistema de ficheros y flujos a ficheros . . . . . . . . . . . . . . 110
7.5.1. El sistema de ficheros . . . . . . . . . . . . . . . . . . . . 110
7.5.2. Flujos a ficheros . . . . . . . . . . . . . . . . . . . . . . . 110
7.6. Serializaci´on . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8. Algunas clases de utilidad del paquete est´andar 117
8.1. La clase Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.2. Trabajo con cadenas de caracteres . . . . . . . . . . . . . . . . . 120
8.2.1. La clase String . . . . . . . . . . . . . . . . . . . . . . . 120
8.2.2. Las clases StringBuffer y StringBuilder . . . . . . . . 121
8.3. Clases recubridoras . . . . . . . . . . . . . . . . . . . . . . . . . . 122
´INDICE GENERAL 5
8.4. Colecciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.5. Trabajo con fechas . . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.5.1. La clase Date . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.5.2. Las clases Calendar y GregorianCalendar . . . . . . . . 129
8.6. Matem´aticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.6.1. La clase Math . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.6.2. La clase Random . . . . . . . . . . . . . . . . . . . . . . . 130
9. Programaci´on con gen´ericos 133
9.1. ¿Qu´e son los tipos de datos gen´ericos? . . . . . . . . . . . . . . . 133
9.2. M´etodos gen´ericos . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9.3. Clases gen´ericas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9.4. Ampliaci´on del tipo gen´erico . . . . . . . . . . . . . . . . . . . . 138
9.4.1. Tipos gen´ericos con l´ımite superior . . . . . . . . . . . . . 139
9.4.2. Comodines . . . . . . . . . . . . . . . . . . . . . . . . . . 139
9.5. Borrado de tipo y compatibilidad con c´odigo heredado . . . . . . 141
10.Construcci´on de proyectos con Ant 143
10.1.Qu´e es Ant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
10.2.Definici´on del proyecto . . . . . . . . . . . . . . . . . . . . . . . . 144
10.2.1. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
10.2.2. Tareas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
10.3.Compilar el c´odigo fuente de un proyecto . . . . . . . . . . . . . 146
10.4.Propiedades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.5.Estructuras path-like . . . . . . . . . . . . . . . . . . . . . . . . 147
10.6.Ejecuci´on de las Pruebas Unitarias . . . . . . . . . . . . . . . . . 148
10.7.Generaci´on de la documentaci´on . . . . . . . . . . . . . . . . . . 150
10.8.Empaquetado de la aplicaci´on . . . . . . . . . . . . . . . . . . . . 151
10.9.Ejecuci´on y limpieza . . . . . . . . . . . . . . . . . . . . . . . . . 151
11.Interfaces gr´aficas de usuario 153
11.1.APIs para la programaci´on de interfaces gr´aficos de usuario en
Java: AWT y Swing . . . . . . . . . . . . . . . . . . . . . . . . . 154
11.2.Contenedores y Componentes . . . . . . . . . . . . . . . . . . . . 155
11.3.Gestores de Aspecto (Layout Managers) . . . . . . . . . . . . . . 155
11.4.Detecci´on de eventos: Escuchadores . . . . . . . . . . . . . . . . . 157
11.5.Algunos componentes Swing . . . . . . . . . . . . . . . . . . . . . 162
11.5.1. JLabel, muestra texto o iconos . . . . . . . . . . . . . . . 162
11.5.2. JButton, botones que el usuario puede pulsar . . . . . . . 162
11.5.3. JTextField, campos de introducci´on de texto . . . . . . . 163
11.5.4. JRadioButton, botones de opciones . . . . . . . . . . . . 164
11.5.5. JCheckBox, botones de selecci´on mu´ltiple . . . . . . . . . 166
11.5.6. JList, listas de selecci´on . . . . . . . . . . . . . . . . . . 166
11.6.El patr´on de disen˜o Modelo/Vista/Controlador . . . . . . . . . . 168
12.Applets 173
12.1.¿Qu´e son los Applets? . . . . . . . . . . . . . . . . . . . . . . . . 173
12.2.Ciclo de vida de un Applet . . . . . . . . . . . . . . . . . . . . . 174
12.3.C´odigo HTML para contener un Applet . . . . . . . . . . . . . . 175
12.4.Lectura de par´ametros de la p´agina HTML . . . . . . . . . . . . 176
6 ´INDICE GENERAL
12.5.Convertir una aplicaci´on Swing en un Applet . . . . . . . . . . . 176
12.6.Comunicaci´on entre Applets . . . . . . . . . . . . . . . . . . . . . 177
13.Control de errores con MyLyn y Bugzilla 181
13.1.Sistema de control de tareas MyLyn . . . . . . . . . . . . . . . . 182
13.1.1. Cual es el objetivo de MyLyn . . . . . . . . . . . . . . . . 182
13.1.2. Trabajar con MyLyn . . . . . . . . . . . . . . . . . . . . . 182
13.2.Sistema de gesti´on de errores Bugzilla . . . . . . . . . . . . . . . 188
13.2.1. Cual es el objetivo de Bugzilla . . . . . . . . . . . . . . . 188
13.2.2. Instalaci´on de Bugzilla . . . . . . . . . . . . . . . . . . . . 188
13.2.3. Trabajar con Bugzilla . . . . . . . . . . . . . . . . . . . . 195
13.3.Acceso a Bugzilla desde MyLyn y Eclipse . . . . . . . . . . . . . 199
13.3.1. Beneficios de la combinaci´on de Bugzilla y MyLyn desde
Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
13.3.2. Trabajo con MyLyn y Bugzilla desde Eclipse . . . . . . . 201
14.Programaci´on concurrente con Hilos 207
14.1.¿Qu´e es un hilo? Utilidades. Consideraciones sobre el uso de hilos 208
14.2.Creaci´on de hilos en Java . . . . . . . . . . . . . . . . . . . . . . 209
14.2.1. Creaci´on de un Hilo extendiendo a la clase Thread . . . . 209
14.2.2. Creaci´on de un Hilo mediante una clase interna . . . . . . 210
14.2.3. Creaci´on de un Hilo mediante una clase interna ano´nima. 211
14.3.Ciclo de vida de un hilo . . . . . . . . . . . . . . . . . . . . . . . 212
14.4.Control de hilos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
14.5.Sincronizaci´on. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
14.5.1. Sincronizac´on utilizando los cerrojos intr´ınsecos . . . . . . 215
14.5.2. Sincronizaci´on utilizando el interface Lock . . . . . . . 218
15.Programaci´on para la Red 221
15.1.Trabajo con URLs . . . . . . . . . . . . . . . . . . . . . . . . . . 222
15.1.1. ¿Qu´e es una URL? . . . . . . . . . . . . . . . . . . . . . . 222
15.1.2. Leer desde una URL . . . . . . . . . . . . . . . . . . . . . 223
15.1.3. Escribir a una URL . . . . . . . . . . . . . . . . . . . . . 223
15.2.Trabajo con Sockets . . . . . . . . . . . . . . . . . . . . . . . . . 225
15.2.1. ¿Qu´e es un Socket?. . . . . . . . . . . . . . . . . . . . . . 225
15.2.2. Sockets bajo el protocolo TCP . . . . . . . . . . . . . . . 225
15.2.3. Sockets bajo el protocolo UDP . . . . . . . . . . . . . . . 227
16.Patrones de disen˜o 231
16.1.Principios de POO . . . . . . . . . . . . . . . . . . . . . . . . . . 232
16.2.¿Qu´e son los patrones de disen˜o? . . . . . . . . . . . . . . . . . . 233
16.3.¿Qu´e es el acoplamiento entre clases y por qu´e hay que evitarlo? 233
16.4.Grupos de patrones de disen˜o . . . . . . . . . . . . . . . . . . . . 233
16.5.El patr´on de disen˜o Singleton . . . . . . . . . . . . . . . . . . . . 233
16.5.1. Situaci´on que intenta resolver . . . . . . . . . . . . . . . . 234
16.5.2. Ejemplo de implementaci´on . . . . . . . . . . . . . . . . . 234
16.6.El patr´on de disen˜o Factory Method . . . . . . . . . . . . . . . . 235
16.6.1. Situaci´on que intenta resolver . . . . . . . . . . . . . . . . 235
16.6.2. Ejemplo de implementaci´on . . . . . . . . . . . . . . . . . 236
16.7.El patr´on de disen˜o Abstract Factory . . . . . . . . . . . . . . . . 238
´INDICE GENERAL 7
16.7.1. Situaci´on que intenta resolver . . . . . . . . . . . . . . . . 238
16.7.2. Ejemplo de implementaci´on . . . . . . . . . . . . . . . . . 238
16.8.El patr´on de disen˜o Strategy . . . . . . . . . . . . . . . . . . . . . 244
16.8.1. Situaci´on que intenta resolver . . . . . . . . . . . . . . . . 245
16.8.2. Ejemplo de implementaci´on . . . . . . . . . . . . . . . . . 245
16.9.El patr´on de disen˜o Observer . . . . . . . . . . . . . . . . . . . . 247
16.9.1. Situaci´on que intenta resolver . . . . . . . . . . . . . . . . 247
16.9.2. Ejemplo de implementaci´on . . . . . . . . . . . . . . . . . 248
16.10.El patr´on de disen˜o Decorator . . . . . . . . . . . . . . . . . . . . 249
16.10.1.Situaci´on que intenta resolver . . . . . . . . . . . . . . . . 250
16.10.2.Ejemplo de implementaci´on . . . . . . . . . . . . . . . . . 250
A. build.xml 255
B. Aplicaci´on Hipoteca 259
C. Ejemplo sincronizaci´on 265
8 ´INDICE GENERAL
Prefacio
Laescrituradeunlibroesunatareaingente.Lamotivaci´onparaabordarladebe
ser, al menos, tan grande como la tarea que se desea acometer. Para nosotros,
la motivaci´on ha consistido en escribir un libro que se distinguiera del resto de
libros que abordan el aprendizaje del lenguaje de programaci´on Java.
Porunlado,existenexcelenteslibrosquemuestranc´omoprogramarenJava.
Por otro lado existen excelentes libros, en nu´mero inferior, que muestran c´omo
utilizar herramientas de ayuda y soporte al desarrollo de proyectos en Java.
Pensamos que, entre ellos, exist´ıa cabida para escribir un libro que abordase el
aprendizaje de Java al mismo tiempo que las herramientas imprescindibles de
ayuda al desarrollo.
Dentro de nuestra Universidad, la Jaume I, hemos impartido, y seguimos
haci´endolo, cursos sobre el lenguaje de programaci´on Java para todo tipo de
alumnado: desde alumnos de las distintas titulaciones de inform´atica, alumnos
extranjeros en el Master Europeo Erasmus Mundus sobre tecnolog´ıas Geoes-
paciales, hasta profesionales que quieren mantener al d´ıa su conocimiento y
mejorar sus expectativas laborales. Esta experiencia nos ha dado la confianza
suficiente como para animarnos a escribir el presente libro.
Y, a pesar del contacto casi diario con Java y sus tecnolog´ıas, reconocemos
queau´nnosquedamuchoporaprender,queelmundoquebrindaelaprendizaje
de Java es inmenso y que se renueva constantemente. Esto u´ltimo es s´ıntoma
de que la comunidad alrededor de esta tecnolog´ıa est´a viva y posee un gran
entusiasmo.
Objetivos del libro
Dos son los objetivos principales del este libro:
Presentar el lenguaje de programaci´on Java.
Presentaralgunasdelasherramientasdedesarrolloqueayudaneneldesa-
rrollo de proyectos utilizando Java.
Conunpocom´asdedetalle,enelprimerobjetivohemospretendidonos´olo
presentar el lenguaje de programaci´on, adem´as indicamos unas directrices para
crear c´odigo de calidad, c´odigo que sea f´acil leer, f´acil mantener y que se puede
probar de manera autom´atica.
El segundo de los objetivos es casi una necesidad imperiosa a los equipos de
desarrollo que siguen utilizando como herramienta de control de versiones un
directorio compartido. O a aquellos equipos de desarrollo que siguen probando
9
10 ´INDICE GENERAL
sus aplicaciones de manera manual. O para aquellos equipos de desarrollo que
utilizancomosistemadeseguimientodeerroreselcorreoelectr´onico.Yunlargo
etc´etera de pr´acticas desaconsejadas.
Co´mo est´a organizado este libro
La Figura 1 muestra la organizaci´on en cap´ıtulos del presente libro. Cada uno
de los recuadros representa un cap´ıtulo. Los cap´ıtulos se han agrupado en dos
grandesbloques.EnelprimerodeellosJavab´asicohemosagrupadoloscap´ıtulos
queconsideramosintroductorios,yquerepresentanelnu´cleodelaprogramaci´on
orientada a objetos en Java. En el segundo grupo Java avanzado aparecen los
cap´ıtulos que consideramos aspectos avanzados del lenguaje con respecto a los
cap´ıtulos del primer grupo.
En ambos grupos hay cap´ıtulos que no aparecen en la l´ınea principal del
flujo, estos cap´ıtulos son los que presentan herramientas que consideramos de
gran utilidad en el desarrollo de proyectos inform´aticos utilizando tecnolog´ıas
Java. El orden de introducci´on de estas herramientas a sido fuente de largas
conversaciones: ¿Es conveniente introducir al principio la herramienta JUnit
siguiendo una orientaci´on hacia el desarrollo guiado por pruebas? ¿Debemos
delegar hasta el segundo bloque de cap´ıtulos el dedicado a la construcci´on de
proyectosconAnt?Hemosoptadoporseguirunordenquiz´asm´asconservadoy
menos arriesgado, intentando presentar las herramientas en el momento en que
conceptualmenteseentiendacualeslanecesidadquevienenacubrir.Esperamos
que esta ordenaci´on haga el tr´ansito suave entre el aprendizaje de Java como
lenguaje de programaci´on y las herramientas de ayuda al desarrollo.
Quien deber´ıa leer este libro
El publico objetivo de este libro son los desarrolladores que quieran aprender
el lenguaje de programaci´on Java y ya posean conocimientos de programaci´on
estructuradayorientaci´onaobjetos.Losconceptosdellenguajesonpresentados
desde la base, suponiendo que es la primera vez que el lector se aproxima al
lenguaje de programaci´on Java.
Pero este libro tambi´en est´a pensado para aquellas personas que conocen el
lenguaje de programaci´on Java y au´n no han descubierto la gran cantidad de
herramientas de ayuda que existen en el desarrollo de proyecto.
Agradecimientos
La secci´on de agradecimientos es posiblemente una de las m´as complicadas de
escribir. Debe tener un equilibrio entre el espacio dedicado a ella y el reconoci-
miento a todas las personas, que de un modo u otro han contribuido a que un
libro tenga su forma final.
Para no dejarnos por citar el nombre de nadie, preferimos ampliar nuestro
agradecimiento a colectivos. En primer lugar a nuestro alumnos, por que a fin
decuentasesaellosalosquevadirigidoestelibro.Consuspreguntas,aprecia-
ciones,comentariosydudasnoshanayudadoadarnoscuentadedondeestaban
los escollos en la lectura de este libro.