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

Descubra el arte y la ciencia de programar en Java y desarrollar aplicaciones. Programar en Java y desarrollar aplicaciones Java son cosas diferentes. Si está interesado en adentrase en ambos caminos, ha llegado al libro indicado. En él conocerá no solo el lenguaje de programación Java, sino también conceptos de diseño y herramientas genéricas o frameworks que le facilitarán la automatización de las tareas rutinarias y repetitivas del desarrollo. En Java a fondo encontrará, desde cero, todas las explicaciones indispensables para navegar por el ecosistema Java. Partirá desde los fundamentos del lenguaje de programación y profundizará hasta aprender el desarrollo de aplicaciones Java que respeten los alineamientos de diseño recomendados por los expertos de la industria. Entre los temas que este libro recoge para desarrollar una aplicación Java, distribuida, basada en microservicios y con acceso a bases de datos, destacan los siguientes: ' El lenguaje Java ' La programación orientada a objetos ' El JDBC (acceso a base de datos) ' Los patrones de diseño, archivos, networking, multithreading y reflection (introspección de clases y objetos) ' El frontend y el backend; este último dividido entre las capas de negocio (façade) y de acceso a datos (DAO). Además, este libro pone en evidencia la necesidad de utilizar frameworks para automatizar ciertas tareas del desarrollo y permitir que, como programador, se enfoque en resolver el problema de su negocio. Por ello, encontrará en esta lectura cómo diseñar, programar y utilizar emuladores de los frameworks más importantes del mercado: Hibernate (MyHibernate), Spring (MySpring) y Spring Boot (MySpringBoot). Sin duda, esta obra le proporcionará las herramientas necesarias para que destaque en el mundo del desarrollo Java, pues cubre todo lo necesario para trabajar con este lenguaje de programación más allá de la versión vigente, y le otorga especial atención a las funciones implementadas en Java 10 y posteriores. Sea un programador principiante o un desarrollador experimentado, este libro es una inversión muy valiosa si desea profundizar en su comprensión y habilidades en Java, y le preparará para los desafíos de programación del mañana.