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 es

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.