Java a fondo Estudio del lenguaje y desarrollo de aplicaciones Ing. Pablo Augusto Sznajdleder Java a fondo / pag. I www.detodoprogramacion.com Queda prohibida la reproducción total o parcial de esta obra, su tratamiento informático y/o la transmisión por cualquier otra forma o medio sin autorización escrita de Alfaomega Grupo Editor Argentino S.A. Edición: Damián Fernández Revisión de estilo: Vanesa García Diseño de interiores y portada: Diego Ay Revisión de armado: Vanesa García Internet: http://www.alfaomega.com.mx Todos los derechos reservados © 2013, por Alfaomega Grupo Editor Argentino S.A. Paraguay 1307, PB, ofi cina 11 ISBN 978-987-1609-36-9 Queda hecho el depósito que prevé la ley 11.723 NOTA IMPORTANTE: La información contenida en esta obra tiene un fi n exclusivamente didáctico y, por lo tanto, no está previsto su aprovechamiento a nivel profesional o industrial. Las indicaciones técnicas y programas incluidos han sido elaborados con gran cuidado por el autor y reproducidos bajo estrictas normas de control. Alfaomega Grupo Editor Argentino S.A. no será jurídicamente responsable por: errores u omisiones; daños y perjuicios que se pudieran atribuir al uso de la información comprendida en este libro, ni por la utilización indebida que pudiera dársele. Los nombres comerciales que aparecen en este libro son marcas registradas de sus propietarios y se mencionan únicamente con fi nes didácticos, por lo que Alfaomega Grupo Editor Argentino S.A. no asume ninguna responsabilidad por el uso que se dé a esta información, ya que no infringe ningún derecho de registro de marca. Los datos de los ejemplos y pantallas son fi cticios, a no ser que se especifi que lo contrario. Los hipervínculos a los que se hace referencia no necesariamente son administrados por la editorial, por lo que no somos responsables de sus contenidos o de su disponibilidad en línea. Empresas del grupo: Argentina: Alfaomega Grupo Editor Argentino, S.A. Paraguay 1307 P.B. “11”, Buenos Aires, Argentina, C.P. 1057 Tel.: (54-11) 4811-7183 / 0887 - E-mail: Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. México: Alfaomega Grupo Editor, S.A. de C.V. Pitágoras 1139, Col. Del Valle, México, D.F., México, C.P. 03100 Tel.: (52-55) 5575-5022 - Fax: (52-55) 5575-2420 / 2490. Sin costo: 01-800-020-4396 E-mail: Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. Colombia: Alfaomega Colombiana S.A. Carrera 15 No. 64 A 29, Bogotá, Colombia PBX (57-1) 2100122 - Fax: (57-1) 6068648 - E-mail: Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. Sznajdleder, Pablo Augusto Java a fondo : estudio del lenguaje y desarrollo de aplicaciones . - 2a ed. - Buenos Aires : Alfaomega Grupo Editor Argentino, 2013. 456 p. ; 24x21 cm. ISBN 978-987-1609-36-9 1. Informática. I. Título. CDD 005.3 Java a fondo / pag. II Chile: Alfaomega Grupo Editor, S.A. General del Canto 370, Providencia, Santiago, Chile Tel.: (56-2) 947-9351 – Fax: (56-2) 235-5786 -E-mail: Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. www.detodoprogramacion.com Dedico este trabajo, con todo mi amor, a mi esposa Analía y a mi hijo Octaviano. Sin ellos, nada tendría sentido. Dedicado también a la memoria de mi tío Beno que, aunque nunca se lo dije, siempre ocupó un lugar importante en mi corazón. “Superman”, por Octaviano Sznajdleder Java a fondo / pag. III www.detodoprogramacion.com V Java a fondo - Ing. Pablo A. Sznajdleder Agradecimientos Quiero agradecer muy especialmente a mi madre Nelly, quien me permitió trabajar en su casa cada vez que Octaviano no me permitió hacerlo en la mía. Mi agradecimiento también a Damián Fernández quien confi ó en mí y me brindó esta gran oportunidad, y a Carlos Álvarez, que, cuando le propuse hacer la revisión técnica, sin dudarlo me respondió “me interesa revisar tu libro”. Agradezco también a Analía Mora con quién cuento incondicionalmente para investigar y resolver cuestiones relacionadas con la tecnología y el desarrollo de aplicaciones. Finalmente, quiero agradecer a Pablo Bergonzi, gurú indiscutido de Java en Argentina, quien siempre está dispuesto a darme una mano cada vez que las cosas no funcionan como deberían hacerlo. Java a fondo / pag. V www.detodoprogramacion.com VII Java a fondo - Ing. Pablo A. Sznajdleder Mensaje del Editor Los conocimientos son esenciales en el desempeño profesional. Sin ellos es imposible lograr las habilidades para competir laboralmente. La universidad o las instituciones de formación para el trabajo ofrecen la oportunidad de adquirir conocimientos que serán aprovechados más adelante en benefi cio propio y de la sociedad. El avance de la ciencia y de la técnica hace necesario actualizar continuamente esos conocimientos. Cuando se toma la decisión de embarcarse en una vida profesional, se adquiere un compromiso de por vida: mantenerse al día en los conocimientos del área u ofi cio que se ha decidido desempeñar. Alfaomega tiene por misión ofrecerles a estudiantes y profesionales conocimientos actualizados dentro de lineamientos pedagógicos que faciliten su utilización y permitan desarrollar las competencias requeridas por una profesión determinada. Alfaomega espera ser su compañera profesional en este viaje de por vida por el mundo del conocimiento. Alfaomega hace uso de los medios impresos tradicionales en combinación con las tecnologías de la información y las comunicaciones (IT) para facilitar el aprendizaje. Libros como este tienen su complemento en una página Web, en donde el alumno y su profesor encontrarán materiales adicionales, información actualizada, pruebas (test) de autoevaluación, diapositivas y vínculos con otros sitios Web relacionados. Esta obra contiene numerosos gráfi cos, cuadros y otros recursos para despertar el interés del estudiante, y facilitarle la comprensión y apropiación del conocimiento. Cada capítulo se desarrolla con argumentos presentados en forma sencilla y estructurada claramente hacia los objetivos y metas propuestas. Cada capítulo concluye con diversas actividades pedagógicas para asegurar la asimilación del conocimiento y su extensión y actualización futuras. Los libros de Alfaomega están diseñados para ser utilizados dentro de los procesos de enseñanza-aprendizaje, y pueden ser usados como textos guía en diversos cursos o como apoyo para reforzar el desarrollo profesional. Alfaomega espera contribuir así a la formación y el desarrollo de profesionales exitosos para benefi cio de la sociedad. Java a fondo / pag. VII www.detodoprogramacion.com VIII Java a fondo - Ing. Pablo A. Sznajdleder Pablo Augusto Sznajdleder Es Ingeniero en Sistemas de Información, egresado de la Universidad Tecnológica Nacional (UTN-FRBA). Actualmente, es profesor en la cátedra de “Algoritmos y Estructuras de Datos” en la UTNFRBA pasando también por la Universidad Nacional de San Martín (UNSAM) y el Instituto de Tecnología ORT Argentina. Trabajó como instructor Java para Sun Mycrosystems, Oracle e Informix/IBM entre otras empresas líderes. Desde 1995 trabaja en sistemas, principalmente, en el desarrollo de aplicaciones empresariales distribuidas: primero en C/C++ y luego, en Java/JEE. En 1996 comenzó a trabajar como Instructor Java para Sun Microsystems y, desde el 2000, se desempeña en la búsqueda y selección de RRHH capacitados en tecnología Java poniendo especial atención en la identifi cación de jóvenes estudiantes sin experiencia laboral previa, pero con gran potencial profesional. Tiene las certifi caciones internacionales Sun Certifi ed Java Programmer (SCJP, 1997) y Sun Certifi ed Java Developer (SCJD, 1998) y, además, está certifi cado como Instructor Ofi cial Java por Sun Microsystems (1997). Acaba de publicar su libro sobre algoritmos y estructuras de datos: Algoritmos a fondo, con implementaciones en C y Java. En el 2010 publicó la primera edición de Java a fondo. En el 2009 participó como revisor técnico en el libro: Análisis y diseño de algoritmos (López, Jeder, Vega) y, en el 2008, publicó HolaMundo pascal, Algoritmos y estructuras de datos, cuyo contenido cubre por completo los temas que abarca la asignatura de igual nombre en la UTN-FRBA. Revisor técnico: Carlos Álvarez Es Licenciado en Análisis de Sistemas, egresado de la Facultad de Ingeniería (UBA). Trabajó durante 10 años como consultor en desarrollo y performance de aplicaciones y, desde el 2010, es Gerente de calidad técnica de software de despegar.com. Java a fondo / pag. VIII www.detodoprogramacion.com Contenido - IX Java a fondo - Ing. Pablo A. Sznajdleder 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 Contenido Java a fondo / pag. IX www.detodoprogramacion.com X - Contenido Java a fondo - Ing. Pablo A. Sznajdleder 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 Java a fondo / pag. X www.detodoprogramacion.com Contenido - XI Java a fondo - Ing. Pablo A. Sznajdleder 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 Java a fondo / pag. XI www.detodoprogramacion.com XII - Contenido Java a fondo - Ing. Pablo A. Sznajdleder 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 .............................................................400 15.9.3 Presentaciones* ............................................................400 16 Inversión del control por inyección de dependencias .................................................................. 401 16.1 Introducción ............................................................................ 402 16.2 Spring framework ................................................................... 402 16.2.1 Desacoplar el procesamiento .......................................404 16.2.2 Conclusión y repaso .....................................................408 16.3 Spring y JDBC ........................................................................ 409 16.4 Integración Spring + Hibernate ............................................. 412 16.5 Resumen ................................................................................. 415 16.6 Contenido de la página Web de apoyo ................................ 416 16.6.1 Mapa conceptual ..........................................................416 16.6.2 Autoevaluación .............................................................416 16.6.3 Presentaciones* ............................................................416 17 Actualización a Java7 ......................................................... 417 17.1 Introducción ............................................................................ 418 17.2 Novedades en Java 7 ............................................................ 418 17.2.1 Literales binarios ...........................................................418 17.2.2 Literales numéricos separados por “_” (guion bajo) ....418 17.2.3 Uso de cadenas en la sentencia switch .......................419 17.2.4 Inferencia de tipos genéricos .......................................419 17.2.5 Sentencia try con recurso incluido ...............................420 17.2.6 Atrapar múltiples excepciones dentro de un mismo bloque catch ..............................................................................420 17.2.7 Nuevos métodos en la clase File .................................420 17.3 Contenido de la página Web de apoyo ................................ 421 17.3.1 Mapa conceptual ..........................................................421 17.3.2 Auto evaluación ............................................................421 17.3.3 Presentaciones* ............................................................421 Apéndice A Nociones básicas de programación .................. 423 A.1 Introducción ............................................................................ 424 A.2 Conceptos iniciales ................................................................ 424 A.2.1 El lenguaje de programación ........................................424 A.2.2 El compilador ................................................................424 A.2.3 Los intérpretes ..............................................................424 A.2.4 Las máquinas virtuales .................................................425 A.2.5 Java y su máquina virtual .............................................425 A.3 Recursos de programación ................................................... 425 A.3.1 Las variables .................................................................425 A.3.2 Tipos de datos .............................................................425 A.3.3 Operadores aritméticos ................................................426 A.3.4 Estructuras de decisión ................................................427 A.3.5 Estructuras de repetición .............................................427 Apéndice B Applets ..................................................................... 429 B.1 Introducción ............................................................................ 430 B.2 Comenzando con Applets ..................................................... 430 B.2.1 El ciclo de vida de un applet ........................................432 B.2.2 El contexto del applet ...................................................433 B.2.3 Pasarle parámetros a un applet ...................................433 Bibliografía ..................................................................................... 435 Java a fondo / pag. XII www.detodoprogramacion.com Contenido - XIII Java a fondo - Ing. Pablo A. Sznajdleder Capítulo 1 Introducción al lenguaje de programación Java • Mapa conceptual • Autoevaluación • Videotutoriales: - Instalar Java y Eclipse. - Crear y ejecutar nuestro primer programa en Eclipse. - Pasar argumentos en línea de comandos en Eclipse. - Compilar y ejecutar un programa Java desde la línea de comandos (sin utilizar Eclipse). • Presentaciones* Capítulo 2 Programación orientada a objetos • Mapa conceptual • Autoevaluación • Videotutoriales: - Utilizar la herramienta "javadoc" para documentar nuestro código fuente. - Empaquetar clases utilizando la herramienta "jar". • Presentaciones* Capítulo 3 Acceso a bases de datos (JDBC) • Mapa conceptual • Autoevaluación • Videotutorial: - Usar Eclipse como cliente SQL. • Presentaciones* Capítulo 4 Diseño de aplicaciones Java (Parte I) • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 5 Interfaz gráfi ca (GUI) • Mapa conceptual • Autoevaluación • Videotutorial: - Utilizar herramientas visuales para diseño y desarrollo de interfaz gráfi ca. • Presentaciones* Capítulo 6 Multithreading (Hilos) • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 7 Networking • Mapa conceptual • Autoevaluación • Videotutorial: - Compilar y ejecutar una aplicación RMI. • Presentaciones* Capítulo 8 Diseño de aplicaciones Java (Parte II) • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 9 Estructuras de datos dinámicas • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 10 Parametrización mediante archivos XML • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 11 Introspección de clases y objetos • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 12 Generalizaciones y desarrollo de frameworks • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 13 Entrada/Salida • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 14 Consideraciones adicionales • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 15 Object Relational Mapping (ORM) y persistencia de datos • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 16 Inversión del control por inyección de dependencias • Mapa conceptual • Autoevaluación • Presentaciones* Capítulo 17 Actualización a Java 7 • Mapa conceptual • Autoevaluación • Presentaciones* Código fuente de cada capítulo Hipervínculos de interés Fe de erratas Guía para el docente de las competencias específi cas que se desarrollan con este libro Información del contenido de la página Web El material marcado con asterisco (*) solo está disponible para docentes. Java a fondo / pag. XIII www.detodoprogramacion.com XIV Java a fondo - Ing. Pablo A. Sznajdleder Registro en la Web de apoyo Para tener acceso al material de la página Web de apoyo del libro: 1. Ir a la página http://virtual.alfaomega.com.mx 2. Registrarse como usuario del sitio y propietario del libro. 3. Ingresar al apartado de inscripción de libros y registrar la siguiente clave de acceso: 4. Para navegar en la plataforma virtual de recursos del libro, usar los nombres de Usuario y Contraseña defi nidos en el punto número dos. El acceso a estos recursos es limitado. Si quiere un número extra de accesos, escriba a Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. Estimado profesor: Si desea acceder a los contenidos exclusivos para docentes, por favor contacte al representante de la editorial que lo suele visitar o escribanos a: Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. Videotutoriales que complementan la obra. Nuevo en Java 7: bajo este ícono se encuentran nuevas formas de resolver algunas cuestiones en Java. Conceptos para recordar: bajo este ícono se encuentran defi niciones importantes que refuerzan lo explicado en la página. Comentarios o información extra: este ícono ayuda a comprender mejor o ampliar el texto principal. Contenidos interactivos: indica la presencia de contenidos extra en la Web. Java a fondo / pag. XIV www.detodoprogramacion.com XV Java a fondo - Ing. Pablo A. Sznajdleder Prólogo A partir de los años ochenta, la Humanidad ha comenzado una nueva revolución, equiparable a la Primera Revolución Industrial: estamos hablando de fi nes del siglo XVIII y principios del XIX de nuestra era, la actual revolución a la que me refi ero es la Tecnológica, con la aparición de las primeras computadoras nos referimos a la década de los sesenta y a partir de los ochenta con las primeras computadoras personales. Luego de este último periodo, hemos vivido avances tecnológicos de manera vertiginosa con cambios que, en un principio, fueron paulatinos pero, ahora, son cada vez más rápidos debido a la aparición de nuevos dispositivos electrónicos como computadoras, celulares, videojuegos, televisores, etcétera. El hardware es cada vez más pequeño, pero más potente, más efi ciente en cuanto a la capacidad en el manejo de la información, siendo atractivo para los usuarios fi nales en precios, portabilidad, tamaño, resolución de pantalla, peso, etcétera. En cuanto al software, este ha avanzado más rápido que el hardware con el desarrollo de nuevos lenguajes de programación, lo que ha obligado a las empresas desarrolladoras del hardware a la compactación y efi ciencia del mismo. Uno de los lenguajes de programación que tiene mayor importancia sobre los demás es Java, el cual es dominante en la creación de aplicaciones empresariales, elaboración de videojuegos, sitios Web, etcétera. Otra característica importante es que Java es multiplataforma, lo que signifi ca que las aplicaciones programadas con este lenguaje pueden “correr” en cualquier sistema operativo y hardware. Esto lo posiciona como el lenguaje de programación más versátil de, al menos, los últimos 15 años. Java, como lenguaje de Programación Orientada a Objetos (POO) requiere del conocimiento de diversas técnicas (Herencia, Polimorfi smo, Abstracción, Encapsulamiento, etc.) las cuales son importantes que el lector domine para poder desarrollar aplicaciones fl exibles, mantenibles, robustas y escalables. Llevado al ámbito empresarial, las aplicaciones Java pueden interactuar con bases de datos, servidores de mensajería asincrónica, servicios de nombres y directorios, Web services, etcétera, lo que facilita enormemente las tareas de integración y el desarrollo de sistemas distribuidos. Por lo expuesto, Java es “mucho más” que un simple lenguaje de programación; y para conocerlo no solo se requiere aprender su sintaxis y semántica. También es fundamental conocer técnicas de diseño que, sumadas a las potencialidades del lenguaje, nos ayuden a desarrollar aplicaciones duraderas en el tiempo. El libro Java a fondo explica cómo desarrollar aplicaciones Java desde un enfoque de diseño y en sintonía con los lineamientos recomendados por los expertos de la industria. Comienza desde cero y avanza progresivamente incorporando conceptos, que se van reforzando a medida que expone ejemplos sencillos y efi caces. El libro se diferencia de los demás porque no aburre con extensas e interminables listas de palabras reservadas, operadores, reglas, clases y métodos. Por el contrario, los conocimientos se proporcionan conforme van siendo necesarios, según sea el ejemplo o caso práctico que se esté analizando en cada capítulo. Aunque Java a fondo solo cubre JSE (Java Standard Edition), plantea y explica las técnicas y los patrones de diseño que son pilares en JEE (Java Enterprise Edition), dejando al lector en la puerta del desarrollo de aplicaciones empresariales. Session Facade, Model View Controller, Factory Method, Data Access Object son algunos de los patrones de diseño que el autor explica con una simpleza que sorprende, haciendo fácil lo que en Internet y en otros libros se presenta como imposible, elitista o para pocos. Java a fondo hace hincapié en el diseño de aplicaciones desarrolladas en capas lógicas, las cuales proveen sus servicios a las capas anteriores y se nutren de los servicios provistos por las capas posteriores. Me refi ero a las famosas “capa de presentación”, “capa de negocios” y “capa de acceso a datos”. Cabe destacar que el autor complementa la obra con una serie de tutoriales en video en los que él mismo explica aquellos temas que, dada su naturaleza, resultan difíciles de explicar en papel. Estos videos cubren, desde cómo instalar Eclipse (la herramienta de desarrollo que el autor recomienda utilizar), hasta cómo montar un entorno de objetos distribuidos RMI; pasando por cómo diseñar visualmente interfaces gráfi cas, cómo usar el debugger, cómo conectarse a la base de datos para ejecutar consultas, etcétera. Finalmente, en esta nueva edición, se incorporan dos capítulos que introducen al lector en el uso de Hibernate y Spring; estos frameworks de “persistencia de objetos” e “inyección de dependencias” respectivamente son extensamente usados en la industria de desarrollo y muchas veces se requiere conocerlos para incorporarse al mercado laboral. Mtro. Jorge Armando Villarreal Ramírez DOCENTE DE TIEMPO COMPLETO UNIVERSIDAD DEL VALLE DE MÉXICO / CAMPUS COYOACÁN Java a fondo / pag. XV www.detodoprogramacion.com XVII Java a fondo - Ing. Pablo A. Sznajdleder Introducción Java a fondo propone un curso de lenguaje y desarrollo de aplicaciones Java basado en un enfoque totalmente práctico, sin vueltas ni rodeos, y contemplando el aprendizaje basado en competencias. 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. Se hace hincapié en la teoría de objetos: polimorfi smo, clases abstractas, interfaces Java y clases genéricas así como en el uso de patrones de diseño que permiten desacoplar las diferentes partes que componen una aplicación para que esta resulte ser 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 lo que la convierte en una herramienta fundamental para obtener las certifi caciones internacionales SCJP (Sun Certifi ed Java Programmer) y SCJD (Sun Certifi ed Java Developer). Para ayudar a clarifi car los conceptos, el autor incluye diagramas UML y una serie de videotutoriales que incrementan notablemente la dinámica del aprendizaje, además de guiar al alumno en el uso de una de las herramientas de desarrollo más utilizadas y difundidas: Eclipse. Java a fondo puede utilizarse como un libro de referencia o como una guía para desarrollar aplicaciones Java ya que la estructuración de los contenidos fue cuidadosamente pensada para este fi n. Entre los Capítulos 1 y 3, se explica el lenguaje de programación, el paradigma de objetos y JDBC que es la API a través de la cual los programas Java se conectan con las bases de datos. El Capítulo 4 explica cómo desarrollar una aplicación Java separada en capas lógicas (“presentación”, “aplicación” y “acceso a datos”) poniendo en práctica los principales patrones de diseño. La aplicación de estudio se conecta a una base de datos e interactúa con el usuario a través de la consola (teclado y pantalla en modo texto). El Capítulo 5 explica AWT y Swing que son las APIs provistas por el lenguaje con las que podemos desarrollar interfaces gráfi cas, permitiendo que el lector programe una capa de presentación más vistosa y amigable para la aplicación desarrollada en el capítulo anterior. En los Capítulos 6 y 7, se estudian los conceptos de multiprogramación y networking: cómo conectar programas a través de la red utilizando los protocolos UDP y TCP, y RMI. Con los conocimientos adquiridos hasta este momento, en el Capítulo 8, se vuelve a analizar la aplicación de estudio del Capítulo 4, pero desde un punto de vista físico diferenciando entre capas lógicas y capas físicas e implementando la capa de aplicación detrás de los servicios de un server. Entre los Capítulos 9 y 11, se estudian conceptos de estructuras de datos, parseo de contenidos XML e introspección de clases y objetos para luego, en el Capítulo 12, aplicarlos en el análisis y desarrollo de un framework que automatiza las tareas rutinarias y repetitivas que hubo que realizar (por ejemplo) para leer archivos XML y para acceder a la base de datos, entre otras cosas. En el Capítulo 13, se estudian conceptos de entrada y salida (I/O streams). El Capítulo 14 profundiza sobre cuestiones que, adrede, no fueron tratadas para evitar confundir al lector. Principalmente, consideraciones sobre concurrencia, multithreading y sobre el uso ciertas clases “legacy”. Java a fondo / pag. XVII www.detodoprogramacion.com XVIII Java a fondo - Ing. Pablo A. Sznajdleder Los Capítulos 15 y 16 introducen al uso de dos frameworks ineludibles: Hibernate y Spring; estos frameworks de “persistencia de objetos” e “inyección de dependencias” respectivamente son ampliamente usados en la industria del software. El último capítulo menciona las principales novedades que incluye la API de Java 7; novedades que también se han ido destacando a lo largo de todo el libro. Para aquellos lectores que no tienen las bases mínimas y necesarias de programación estructurada, se incluye un apéndice de programación inicial. Se ofrece también un apéndice que explica cómo desarrollar Applets. El docente debe saber que, en cada capítulo, se mencionan las competencias específi cas a desarrollar y que en la página Web del libro dispone de una guía detallada de las competencias que se desarrollan a lo largo del libro y las evidencias que se puede