JAVA A FONDO

1 Introducción al lenguaje de programación Java ............. 1
1.1 Introducción ................................................................................. 2
1.2 Comencemos a programar ........................................................ 2
1.2.1 El Entorno Integrado de Desarrollo (IDE) ..........................3
1.3 Estructuras de control ................................................................ 3
1.3.1 Entrada y salida de datos por consola ............................3
1.3.2 Defi nición de variables ......................................................4
1.3.3 Comentarios en el código ................................................5
1.3.4 Estructuras de decisión ....................................................6
1.3.5 Estructuras iterativas ......................................................10
1.4 Otros elementos del lenguaje .................................................. 12
1.4.1 Tipos de datos ...............................................................12
1.4.2 Algunas similitudes y diferencias con C y C++ ..............12
1.4.3 Defi nición de constantes ................................................13
1.4.4 Arrays .............................................................................14
1.4.5 Matrices ..........................................................................17
1.4.6 Literales de cadenas de caracteres ...............................18
1.4.7 Caracteres especiales ....................................................20
1.4.8 Argumentos en línea de comandos ...............................21
1.5 Tratamiento de cadenas de caracteres .................................. 22
1.5.1 Acceso a los caracteres de un String ............................22
1.5.2 Mayúsculas y minúsculas ...............................................23
1.5.3 Ocurrencias de caracteres .............................................23
1.5.4 Subcadenas ...................................................................24
1.5.5 Prefi jos y sufi jos ..............................................................24
1.5.6 Posición de un substring dentro de la cadena ..............25
1.5.7 Concatenar cadenas ......................................................25
1.5.8 La clase StringBuffer ......................................................26
1.5.9 Conversión entre números y cadenas ...........................27
1.5.10 Representación numérica en diferentes bases ..............28
1.5.11 La clase StringTokenizer .................................................29
1.5.12 Usar expresiones regulares para particionar
una cadena .....................................................................30
1.5.13 Comparación de cadenas ..............................................31
1.6 Operadores .............................................................................. 33
1.6.1 Operadores aritméticos ..................................................33
1.6.2 Operadores lógicos ........................................................33
1.6.3 Operadores relacionales .................................................34
1.6.4 Operadores lógicos de bit ..............................................34
1.6.5 Operadores de desplazamiento de bit ...........................34
1.7 La máquina virtual y el JDK ..................................................... 34
1.7.1 El JDK (Java Development Kit) .......................................35
1.7.2 Versiones y evolución del lenguaje Java ........................35
1.8 Resumen ................................................................................... 35
1.9 Contenido de la página Web de apoyo .................................. 36
1.9.1 Mapa conceptual ............................................................36
1.9.2 Autoevaluación ...............................................................36
1.9.3 Videotutoriales ................................................................36
1.9.4 Presentaciones* ..............................................................36
2 Programación orientada a objetos .................................... 37
2.1 Introducción .............................................................................. 38
2.2 Clases y objetos ....................................................................... 38
2.2.1 Los métodos ..................................................................39
2.2.2 Herencia y sobrescritura de métodos ............................41
2.2.3 El método toString .........................................................41
2.2.4 El método equals ............................................................42
2.2.5 Defi nir y "crear" objetos ..................................................43
2.2.6 El constructor .................................................................44
2.2.7 Un pequeño repaso de lo visto hasta aquí ....................45
2.2.8 Convenciones de nomenclatura ....................................46
2.2.9 Sobrecarga .....................................................................47
2.2.10 Encapsulamiento ............................................................50
2.2.11 Visibilidad de métodos y atributos .................................52
2.2.12 Packages (paquetes) ......................................................54
2.2.13 La estructura de los paquetes y la variable
CLASSPATH ...................................................................54
2.2.14 Las APIs ("Application Programming Interface") ............55
2.2.15 Representación gráfi ca UML ..........................................55
2.2.16 Importar clases de otros paquetes ................................56
2.3 Herencia y polimorfi smo .......................................................... 57
2.3.1 Polimorfi smo ...................................................................59
2.3.2 Constructores de subclases ..........................................61
2.3.3 La referencia super .........................................................62
2.3.4 La referencia this ............................................................64
2.3.5 Clases abstractas ...........................................................65
2.3.6 Constructores de clases abstractas ...............................69
2.3.7 Instancias ........................................................................72
2.3.8 Variables de instancia .....................................................73
2.3.9 Variables de la clase .......................................................75
2.3.10 El Garbage Collector (recolector de residuos) ...............75
2.3.11 El método fi nalize ...........................................................76
2.3.12 Constantes .....................................................................77
2.3.13 Métodos de la clase .......................................................77
2.3.14 Clases utilitarias ..............................................................79
2.3.15 Referencias estáticas .....................................................79
2.3.16 Colecciones (primera parte) ...........................................81
2.3.17 Clases genéricas ............................................................86
2.3.18 Implementación de una pila (estructura de datos) .........88
2.3.19 Implementación de una cola (estructura de datos) ........90
2.4 Interfaces .................................................................................. 91
2.4.1 Desacoplamiento de clases ..........................................93
2.4.2 El patrón de diseño factory method ...............................95
2.4.3 Abstracción a través de interfaces .................................95
2.4.4 La interface comparable .................................................95
2.4.5 Desacoplar aún más ......................................................99
2.5 Colecciones ............................................................................ 103
2.5.1 Cambio de implementación .........................................105
2.6 Excepciones ........................................................................... 106
2.6.1 Excepciones declarativas y no declarativas .................109
2.6.2 El bloque try-catch-fi nally ............................................111
2.7 Resumen ................................................................................. 112
2.8 Contenido de la página Web de apoyo ................................ 112
2.8.1 Mapa conceptual ..........................................................112
2.8.2 Autoevaluación .............................................................112
2.8.3 Videotutoriales ..............................................................112
2.8.4 Presentaciones* ............................................................112
3 Acceso a bases de datos (JDBC) .................................... 113
3.1 Introducción ............................................................................ 114
3.2 Conceptos básicos sobre bases de datos relacionales ..... 114
3.2.1 Relaciones foráneas y consistencia de datos ..............115
3.2.2 Diagrama Entidad-Relación (DER) ...............................115
3.2.3 SQL - Structured Query Language ..............................116
3.2.4 Ejecutar sentencias query ............................................116
3.2.5 Unir tablas (join) ............................................................117
3.2.6 Ejecutar sentencias UPDATE .......................................117
3.3 Conectar programas Java con bases de datos .................. 118
3.3.1 Invocar un query con un join ........................................123
3.3.2 Updates ........................................................................123
3.3.3 Ejecutar un INSERT ......................................................123
3.3.4 Ejecutar un DELETE .....................................................125
3.3.5 Ejecutar un UPDATE .....................................................125
3.3.6 El patrón de diseño "Singleton" (Singleton Pattern) .....125
3.3.7 Singleton Pattern para obtener la conexión .................126
3.3.8 El shutdown hook .........................................................128
3.3.9 Inner classes (clases internas) ......................................128
3.3.10 Manejo de transacciones .............................................129
3.4 Uso avanzado de JDBC ....................................................... 131
3.4.1 Acceso a la metadata del resultSet
(ResultSetMetaData) .....................................................131
3.4.2 Defi nir el "Query Fetch Size" para conjuntos de
resultados grandes .............................................................. 133
3.4.3 Ejecutar batch updates (procesamiento por lotes) ......133
3.5 Resumen ................................................................................. 134
3.6 Contenido de la página Web de apoyo
3.6.1 Mapa conceptual ..........................................................135
3.6.2 Autoevaluación .............................................................135
3.6.3 Videotutorial ..................................................................135
3.6.4 Presentaciones* ............................................................135
4 Diseño de aplicaciones Java (Parte I) ............................. 137
4.1 Introducción ............................................................................ 138
4.2 Atributos de una aplicación ................................................... 138
4.2.1 Casos de uso ...............................................................138
4.3 Desarrollo de aplicaciones en capas .................................... 139
4.3.1 Aplicación de estudio ...................................................140
4.3.2 Análisis de los objetos de acceso a datos
(DAO y DTO) .................................................................141
4.3.3 Análisis del façade ........................................................145
4.3.4 Diagrama de secuencias de UML ................................147
4.4 Portabilidad entre diferentes bases de datos ...................... 148
4.4.1 DAOs abstractos e implementaciones específi cas
para las diferentes bases de datos ............................ 150
4.4.2 Implementación de un factory method ........................153
4.4.3 Combinar el factory method con el singleton pattern ..154
4.4.4 Mejorar el diseño de los DAOs abstractos ..................156
4.5 Diseño por contratos ............................................................. 158
4.5.1 Coordinación de trabajo en equipo ..............................158
4.6 Resumen ................................................................................. 160
4.7 Contenido de la página Web de apoyo ................................ 160
4.7.1 Mapa conceptual ..........................................................160
4.7.2 Autoevaluación .............................................................160
4.7.3 Presentaciones* ............................................................160
5 Interfaz gráfi ca (GUI) ........................................................... 161
5.1 Introducción ............................................................................ 162
5.2 Componentes y contenedores .............................................. 162
5.2.1 Distribución de componentes (layouts) ........................163
5.2.2 AWT y Swing ................................................................163
5.3 Comenzando a desarrollar GUI ............................................. 164
5.3.1 Distribuciones relativas .................................................164
5.3.2 FlowLayout ...................................................................164
5.3.3 BorderLayout ................................................................167
5.3.4 GridLayout ....................................................................168
5.3.5 Combinación de layouts ...............................................170
5.4 Capturar eventos .................................................................... 176
5.4.1 Tipos de eventos ..........................................................180
5.4.2 Eventos de acción ........................................................181
5.4.3 Eventos de teclado ......................................................184
5.5 Swing ....................................................................................... 186
5.5.1 Cambiar el LookandFeel ..............................................190
5.6 Model View Controller (MVC) ................................................ 192
5.6.1 Ejemplo de uso: ListModel ...........................................192
5.6.2 Ejemplo de uso: TableModel ........................................195
5.7 Resumen ................................................................................. 197
5.8 Contenido de la página Web de apoyo ................................ 198
5.8.1 Mapa conceptual ..........................................................198
5.8.2 Autoevaluación .............................................................198
5.8.3 Videotutorial ..................................................................198
5.8.4 Presentaciones* ............................................................198
6 Multithreading (Hilos) ......................................................... 199
6.1 Introducción ............................................................................ 200
6.2 Implementar threads en Java ................................................ 201
6.2.1 La interface Runnable ...................................................202
6.2.2 Esperar a que fi nalice un thread ...................................203
6.2.3 Threads y la interfaz gráfi ca ..........................................204
6.2.4 Sistemas operativos multitarea ....................................206
6.2.5 Ciclo de vida de un thread ...........................................207
6.2.6 Prioridad de ejecución ..................................................209
6.3 Sincronización de threads ..................................................... 209
6.3.1 Monitores y sección crítica ...........................................210
6.3.2 Ejemplo del Productor/Consumidor .............................210
6.4 Resumen ................................................................................. 214
6.5 Contenido de la página Web de apoyo ................................ 215
6.5.1 Mapa conceptual ..........................................................215
6.5.2 Autoevaluación .............................................................215
6.5.3 Presentaciones* ............................................................215
7 Networking ............................................................................ 217
7.1 Introducción ............................................................................ 218
7.2 Conceptos básicos de networking ....................................... 218
7.2.1 TCP - "Transmission Control Protocol" ........................218
7.2.2 UDP - "User Datagram Protocol" .................................218
7.2.3 Puertos .........................................................................219
7.2.4 Dirección IP ..................................................................219
7.2.5 Aplicaciones cliente/servidor ........................................219
7.3 TCP en Java ........................................................................... 219
7.3.1 El socket .......................................................................219
7.3.2 Un simple cliente/servidor en Java ..............................219
7.3.3 Serialización de objetos ................................................222
7.3.4 Implementación de un servidor multithread .................223
7.3.5 Enviar y recibir bytes ....................................................225
7.3.6 Enviar y recibir valores de tipos de datos primitivos ....228
7.4 UDP en Java ........................................................................... 228
7.5 Remote Method Invocation (RMI) ......................................... 230
7.5.1 Componentes de una aplicación RMI ..........................231
7.5.2 Ejemplo de una aplicación que utiliza RMI ...................231
7.5.3 Compilar y ejecutar la aplicación RMI ..........................233
7.5.4 RMI y serialización de objetos ......................................234
7.6 Resumen ................................................................................. 234
7.7 Contenido de la página Web de apoyo ................................ 234
7.7.1 Mapa conceptual ..........................................................234
7.7.2 Autoevaluación .............................................................234
7.7.3 Videotutorial ..................................................................234
7.7.4 Presentaciones* ............................................................234
8 Diseño de aplicaciones Java (Parte II) ........................... 235
8.1 Introducción ............................................................................ 236
8.2 Repaso de la aplicación de estudio ..................................... 236
8.3 Capas lógicas vs. capas físicas ............................................ 238
8.3.1 Desventajas de un modelo basado en dos
capas físicas .................................................................238
8.3.2 Modelo de tres capas físicas ........................................239
8.4 Desarrollo de la aplicación en tres capas físicas ................ 240
8.4.1 Desarrollo del servidor ..................................................240
8.4.2 Desarrollo de un cliente de prueba ..............................244
8.4.3 El service locator (o ubicador de servicios) ..................246
8.4.4 Integración con la capa de presentación .....................251
8.5 Implementación del servidor con tecnología RMI ............... 253
8.5.1 El servidor RMI .............................................................253
8.5.2 El ServiceLocator y los objetos distribuidos ................255
8.5.3 Desarrollo de un cliente de prueba ..............................256
8.5.4 Integración con la capa de presentación .....................257
8.5.5 El bussiness delegate ...................................................259
8.6 Concurrencia y acceso a la base de datos .......................... 259
8.6.1 El pool de conexiones ..................................................260
8.6.2 Implementación de un pool de conexiones .................260
8.6.3 Integración con los servidores TCP y RMI ...................265
8.7 Resumen ................................................................................. 266
8.8 Contenido de la página Web de apoyo ................................ 266
8.8.1 Mapa conceptual ..........................................................266
8.8.2 Autoevaluación .............................................................266
8.8.3 Presentaciones* ............................................................266
9 Estructuras de datos dinámicas ...................................... 267
9.1 Introducción ............................................................................ 268
9.2 Estructuras dinámicas ........................................................... 268
9.2.1 El nodo .........................................................................268
9.2.2 Lista enlazada (LinkedList) ...........................................269
9.2.3 Pila ................................................................................273
9.2.4 Cola ..............................................................................274
9.2.5 Implementación de una cola sobre una lista circular ...275
9.2.6 Clases LinkedList, Stack y Queue ...............................277
9.2.7 Tablas de dispersión (Hashtable) .................................278
9.2.8 Estructuras de datos combinadas ...............................280
9.2.9 Árboles .........................................................................282
9.2.10 Árbol binario de búsqueda ...........................................283
9.2.11 La clase TreeSet ...........................................................284
9.3 Resumen ................................................................................. 284
9.4 Contenido de la página Web de apoyo ................................ 284
9.4.1 Mapa conceptual ..........................................................284
9.4.2 Autoevaluación .............................................................284
9.4.3 Presentaciones* ............................................................284
10 Parametrización mediante archivos XML ...................... 285
10.1 Introducción ............................................................................ 286
10.2 XML - "Extensible Markup Language" ................................. 286
10.3 Estructurar y defi nir parámetros en un archivo XML ........... 287
10.3.1 Defi nición de la estructura de parámetros ...................287
10.3.2 Leer y parsear el contenido de un archivo XML ..........289
10.3.3 Acceder a la información contenida
en el archivo XML .........................................................292
10.4 Resumen ................................................................................. 300
10.5 Contenido de la página Web de apoyo ................................ 300
10.5.1 Mapa conceptual ..........................................................300
10.5.2 Autoevaluación .............................................................300
10.5.3 Presentaciones* ............................................................300
11 Introspección de clases y objetos .................................. 301
11.1 Introducción ............................................................................ 302
11.2 Comenzando a introspectar .................................................. 303
11.2.1 Identifi car métodos y constructores .............................303
11.2.2 Acceso al prototipo de un método ..............................305
11.3 Annotations ............................................................................. 307
11.4 Resumen ................................................................................. 310
11.5 Contenido de la página Web de apoyo ................................ 310
11.5.1 Mapa conceptual ..........................................................310
11.5.2 Autoevaluación .............................................................310
11.5.3 Presentaciones* ............................................................310
12 Generalizaciones y desarrollo de frameworks ............. 311
12.1 Introducción ............................................................................ 312
12.2 ¿Qué es un framework? ........................................................ 312
12.2.1 ¿Frameworks propios o frameworks de terceros? ......313
12.2.2 Reinventar la rueda .......................................................313
12.3 Un framework para acceder a archivos XML ...................... 314
12.3.1 Diseño de la API del framework ...................................315
12.3.2 Análisis del elemento a generalizar ..............................317
12.3.3 Parsear el archivo XML y cargar la estructura
de datos .......................................................................318
12.4 Un framework para acceder a bases de datos ................... 324
12.4.1 Identifi cación de la tarea repetitiva ...............................325
12.4.2 Diseño de la API del framework ...................................326
12.4.3 Java Beans ...................................................................327
12.4.4 Transacciones ...............................................................338
12.4.5 Mappeo de tablas usando annotations .......................342
12.5 El bean factory ........................................................................ 345
12.6 Integración .............................................................................. 347
12.6.1 Los objetos de acceso a datos ....................................347
12.6.2 El façade .......................................................................348
12.6.3 El archivo de confi guración ..........................................349
12.6.4 El cliente .......................................................................350
12.8 Resumen ................................................................................. 351
12.9 Contenido de la página Web de apoyo ................................ 351
12.9.1 Mapa conceptual ..........................................................351
12.9.2 Autoevaluación .............................................................351
12.9.3 Presentaciones* ............................................................351
13 Entrada/Salida ..................................................................... 353
13.1 Introducción ............................................................................ 354
13.2 I/O streams (fl ujos de entrada y salida) ................................ 354
13.2.1 Entrada y salida estándar .............................................354
13.2.2 Redireccionar la entrada y salidas estándar ................355
13.2.3 Cerrar correctamente los streams ...............................356
13.2.4 Streams de bytes (InputStream y OutputStream) ........357
13.2.5 Streams de caracteres (readers y writers) ....................358
13.2.6 Streams bufferizados ....................................................359
13.2.7 Streams de datos (DataInputStream
y DataOutputStream) ....................................................360
13.2.8 Streams de objetos (ObjectInputStream
y ObjectOutputStream) .................................................361
13.3 Resumen ................................................................................. 363
13.4 Contenido de la página Web de apoyo ................................ 364
13.4.1 Mapa conceptual ..........................................................364
13.4.2 Autoevaluación .............................................................364
13.4.3 Presentaciones* ............................................................364
14 Consideraciones fi nales .................................................... 365
14.1 Introducción ............................................................................ 366
14.2 Consideraciones sobre multithreading y concurrencia ...... 366
14.2.1 Clases con o sin métodos sincronizados ....................366
14.2.2 El singleton pattern en contextos multithreaded .........366
14.3 Consideraciones sobre clases "legacy" ............................... 367
14.3.1 La clase StringTokenizer y el método split ...................367
14.4 Resumen ................................................................................. 368
14.5 Contenido de la página Web de apoyo ................................ 368
14.5.1 Mapa conceptual ..........................................................368
14.5.2 Autoevaluación .............................................................368
14.5.3 Presentaciones* ............................................................368
15 Object Relational Mapping (ORM)
y persistencia de datos ...................................................... 369
15.1 Introducción ............................................................................ 370
15.2 Hibernate framework .............................................................. 371
15.2.1 El modelo de datos relacional ......................................371
15.2.2 ORM (Object Relational Mapping) ................................372
15.2.3 Confi guración de Hibernate .........................................372
15.2.4 Mappeo de tablas ........................................................373
15.2.5 La sesión de Hibernate ................................................375
15.3 Asociaciones y relaciones ..................................................... 375
15.3.1 Asociación many-to-one ..............................................375
15.3.2 Asociación one-to-many ..............................................377
15.3.3 P6Spy ...........................................................................378
15.3.4 Lazy loading vs. eager loading .....................................379
15.4 Recuperar colecciones de objetos ....................................... 381
15.4.1 Criterios de búsqueda vs. HQL ....................................381
15.4.2 Named queries .............................................................383
15.4.3 Ejecutar SQL nativo ......................................................384
15.4.4 Queries parametrizados ...............................................384
15.5 Insertar, modifi car y eliminar fi las ......................................... 384
15.5.1 Transacciones ...............................................................384
15.5.2 Insertar una fi la .............................................................385
15.5.3 Estrategia de generación de claves primarias .............385
15.5.4 Modifi car una fi la ..........................................................386
15.5.5 Múltiples updates y deletes ..........................................386
15.6 Casos avanzados ................................................................... 387
15.6.1 Análisis y presentación del modelo de datos ...............387
15.6.2 Asociaciones many-to-many ........................................388
15.6.3 Claves primarias compuestas (Composite Id) .............390
15.7 Diseño de aplicaciones .......................................................... 392
15.7.1 Factorías de objetos .....................................................393
15.8 Resumen ................................................................................. 399
15.9 Contenido de la página Web de apoyo ................................ 400
15.9.1 Mapa conceptual ..........................................................400
15.9.2 Autoevaluación .........................................

Java a fondo, ya en su segunda edición, es un curso universitario de lenguaje y desarrollo de aplicaciones Java (actualizado a la versión 7) basado en un enfoque totalmente práctico, sin vueltas ni rodeos. El libro comienza desde un nivel 'cero' y avanza hasta llegar a temas complejos como introspección de clases y objetos, acceso a bases de datos (JDBC), multiprogramación, networking y objetos distribuidos (RMI), entre otros. Incluye introducción a Hibernate y Spring. Se hace hincapié en la teoría de objetos: polimorfismo, clases abstractas,interfaces Java y clases genéricas así como en el uso de patrones de diseño que permitan desacoplar las diferentes partes que componen una aplicación para que esta resulte mantenible, extensible y escalable. La obra explica cómo diseñar y desarrollar aplicaciones Java respetando los estándares y lineamientos propuestos por los expertos de la industria convirtiéndose así en una herramienta fundamental para obtener las certificaciones internacionales SCJP (Sun Certified Java Programmer) y SCJD (Sun Certified Java Developer). Para ayudar a clarificar los conceptos, el autor incluye diagramas UML y una serie de videotutoriales que incrementan notablemente la dinámica del aprendizaje.