Java a fondo : estudio del lenguaje y desarrollo de aplicaciones - Brossura

Sznajdleder, Pablo Augusto

Brossura

ISBN 10: 8426719783 ISBN 13: 9788426719782

Casa editrice: Marcombo, 2013

Riassunto

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.

Su questo libro

Contenuti

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) ............................

Dettagli dell?edizione

• Editore: Marcombo
• Data di pubblicazione: 2013
• Lingua: Spagnolo
• ISBN 10: 8426719783
• ISBN 13: 9788426719782
• Rilegatura: Copertina flessibile
• Numero edizione: 1
• Numero di pagine: 436
• Contatto del produttore: non disponibile