Curso de Java en los entornos profesionales 2025 - Tapa blanda

 Este curso integral de Java abarca temas fundamentales hasta avanzados, desde la historia de Java y la arquitectura de la máquina virtual hasta las características principales del lenguaje, las funcionalidades de la API y las mejores prácticas en el diseño orientado a objetos, el manejo de excepciones y las construcciones modernas de Java como lambdas.

 Cubre meticulosamente la evolución de Java, la instalación, las estructuras de clases, los tipos de variables, los operadores, las declaraciones de control, las colecciones, la API de fecha y hora y el diseño de métodos, construyendo una sólida comprensión de la programación de Java. 

Comenzando con el origen de Java en la década de 1990, el curso destaca su filosofía distintiva de "Escribir una vez, ejecutar en cualquier lugar" habilitada por la máquina virtual Java (JVM), que ejecuta código de bytes independiente de la plataforma. 

El propio lenguaje Java se presenta como fuertemente orientado a objetos con características esenciales como primitivas, referencias, clases, métodos y paquetes. Las explicaciones detalladas cubren la configuración de desarrollo (JDK y Eclipse IDE) y la anatomía de las clases de Java, incluidas las propiedades, los métodos, los constructores, los bloques de inicialización y el método principal como punto de entrada del programa. 

Hace hincapié en la encapsulación, los ámbitos de las variables y las distinciones entre los datos primitivos y los tipos de referencia. El curso avanza a operadores Java y construcciones de flujo de control como if-else, bucles (while, do-while, for, for-each), switch y controles avanzados como bucles anidados, etiquetas, interrupciones y continuaciones. Explica temas complejos como la precedencia de operadores, los operadores unarios frente a los binarios, los operadores compuestos, la conversión y las promociones numéricas. 

Las API de Java, especialmente las clases String y StringBuilder, se exploran a fondo, haciendo hincapié en la inmutabilidad y la eficiencia de la memoria. Se tratan los marcos de recopilación, centrándose en matrices, ArrayLists, genéricos, conversión automática y conversiones. El manejo de fechas y horas a través de la moderna API java.time reemplaza las clases más antiguas y engorrosas, con ilustraciones detalladas de creación, manipulación, formato y análisis. 

🚀 DISCOVER IT NOW on Amazon! 🚀

El diseño y la encapsulación de métodos ocupan una parte significativa, explicando los modificadores de acceso (público, privado, protegido, predeterminado), los encabezados de métodos, la sobrecarga, los varargs, el paso de parámetros por valor y los miembros estáticos. El curso promueve las mejores prácticas como el encadenamiento de constructores, el orden de inicialización, la inmutabilidad y los patrones de uso de la API. Se abordan ampliamente los principios avanzados orientados a objetos, como la herencia, las clases abstractas, las interfaces y el polimorfismo. 

El curso diferencia entre la invalidación, la ocultación y la sobrecarga de métodos, aclara las reglas de acceso, excepciones y visibilidad, y desmitifica la resolución de métodos en tiempo de ejecución. Se examinan las características modernas de las interfaces, como los métodos predeterminados y estáticos, junto con los múltiples desafíos de herencia resueltos por las interfaces. 

Por último, se detalla el manejo de excepciones, desde los conceptos básicos de los bloques try-catch-finally, las excepciones comprobadas frente a las no comprobadas, las reglas de propagación de excepciones, la captura de múltiples excepciones, el relanzamiento y las mejores prácticas en el manejo de errores, concluyendo con la forma en que Java fomenta un código robusto y mantenible a través de una gestión de errores disciplinada. En general, este curso proporciona conocimientos profundos y escalonados para desarrollar experiencia desde los fundamentos de Java hasta las técnicas de programación idiomáticas y avanzadas.

🟨 Puntos destacados

• 🖥️ La JVM ejecuta bytecode, lo que permite la independencia de plataforma de Java: “Escribe una vez, ejecuta en cualquier lugar.”

• 💡 Java aplica de forma estricta los principios de la programación orientada a objetos: clases, objetos, encapsulación y herencia.

• 🧮 Cobertura completa de los operadores y estructuras de control de flujo en Java, incluyendo bucles avanzados, switch y expresiones condicionales.

• 🔤 Análisis profundo del uso de la API de Java: inmutabilidad de String, uso de StringBuilder para mejorar el rendimiento, y colecciones con genéricos y autoboxing.

• 📅 La API moderna de Fecha y Hora (Java 8+) reemplazó las clases antiguas para una gestión más clara e inmutable del tiempo y las fechas.

• 🛠️ Principios de diseño de métodos.

• 🛡️ Gestión de excepciones.

Java course 2025: Java course: Java programming at professional environments (English Edition)

### Summary
This comprehensive Java course spans foundational to advanced topics, starting from Java’s history and virtual machine architecture to core language features, API functionalities, and best practices in object-oriented design, exception handling, and modern Java constructs like lambdas. It meticulously covers Java's evolution, installation, class structures, variable types, operators, control statements, collections, date/time API, and method design, building a robust understanding of Java programming.

Beginning with Java’s origin in the 1990s, the course highlights its hallmark philosophy of “Write Once, Run Anywhere” enabled by the Java Virtual Machine (JVM), which executes platform-independent bytecode. The Java language itself is introduced as strongly object-oriented with essential features such as primitives, references, classes, methods, and packages. Detailed explanations cover development setup (JDK and Eclipse IDE) and the anatomy of Java classes—including properties, methods, constructors, initialization blocks, and the main method as the program entry point. It emphasizes encapsulation, variable scopes, and distinctions between primitive data and reference types.

The course progresses to Java operators and control flow constructs like if-else, loops (while, do-while, for, for-each), switch, and advanced controls such as nested loops, labels, breaks, and continues. It explains complex topics like operator precedence, unary vs. binary operators, compound operators, casting, and numerical promotions.

Java APIs, especially the String and StringBuilder classes, are explored thoroughly, stressing immutability and memory efficiency. Collection frameworks are covered with focus on arrays, ArrayLists, generics, autoboxing, and conversions. Handling dates and times via the modern java.time API replaces older, cumbersome classes, with detailed creation, manipulation, formatting, and parsing illustrations.

Method design and encapsulation occupy a significant portion, explaining access modifiers (public, private, protected, default), method headers, overloading, varargs, passing parameters by value, and static members. The course promotes best practices like builder chaining, initialization order, immutability, and API usage patterns.

Advanced object-oriented principles including inheritance, abstract classes, interfaces, and polymorphism are extensively addressed. The course differentiates method overriding, hiding, and overloading, clarifies rules for access, exceptions, and visibility, and demystifies method resolution at runtime. Interfaces’ modern features like default and static methods are examined along with multiple inheritance challenges resolved by interfaces.

Finally, exception handling is detailed, from basics of try-catch-finally blocks, checked vs. unchecked exceptions, exception propagation rules, catching multiple exceptions, re-throwing, and best practices in error handling, wrapping up with how Java fosters robust, maintainable code through disciplined error management.

Overall, this course provides in-depth, stepwise knowledge to build expertise from Java fundamentals to idiomatic and advanced programming techniques.

🚀 DISCOVER IT NOW on Amazon! 🚀


### Highlights
- 🖥️ JVM executes bytecode enabling Java’s platform independence: “Write Once, Run Anywhere.”
- 💡 Java strongly enforces object-oriented principles with classes, objects, encapsulation, and inheritance.
- 🧮 Comprehensive coverage of Java operators and flow controls including advanced loops, switch, and conditional expressions.
- 🔤 Deep dive into Java API usage: String immutability, StringBuilder for performance, and collections with generics and autoboxing.
- 📅 Modern Java 8+ Date and Time API replaced legacy classes for clear, immutable date-time handling.
- 🛠️ Method design principles
- 🛡️ Exception handling

Diseno-de-Bases-de-Datos-Tecnologías-de-servidor

Productos que constituyen las tecnologías de servidores Oracle:

• La Base de Datos Oracle
• Oracle WebLogic Server
• Oracle Enterprise Manager
• Herramientas y lenguajes de desarrollo de aplicaciones

La base de datos es el repositorio de datos y el motor que gestiona el acceso a los mismos. 

Oracle WebLogic Server ejecuta el software que genera las interfaces de usuario web que envían las llamadas para la recuperación y modificación de los datos, para su ejecución. 

Oracle Enterprise Manager es una completa herramienta de administración para la supervisión y gestión, ajusta los procesos de Oracle y también productos de terceros.

Herramientas y lenguajes para el desarrollo de aplicaciones, ya sean aplicaciones que se ejecutan en los equipos de los usuarios finales en el modelo cliente-servidor o en las aplicaciones que se ejecutan en servidores de aplicaciones.

La combinación de las tecnologías de servidor y las herramientas de desarrollo conforman una plataforma para el desarrollo y entrega de aplicaciones que permite la nube. 

La nube es un enfoque para la entrega de servicios de IT que maximiza la eficiencia de costes de todo el entorno mediante la entrega de potencia de computación a partir de un conjunto de recursos disponibles, bajo demanda.

 La Arquitectura del Servidor Oracle
Una base de datos Oracle es un conjunto de archivos en disco. 

No hay límites de tamaño o número de estos archivos y, por lo tanto, no hay prácticamente límites de tamaño de una base de datos. 

El acceso a la base de datos se realiza a través de la instancia Oracle. 

La instancia es un conjunto de procesos y estructuras de memoria

Los usuarios de la base de datos establecen conexión contra la instancia y a continuación, ésta gestiona todos los accesos a la base de datos. 

En el entorno Oracle es absolutamente imposible para cualquier usuario tener contacto directo con la base de datos. 

Una instancia de Oracle con una base de datos Oracle conforma un servidor Oracle.

El modelo de procesado implementado por el servidor Oracle es el de cliente-servidor a menudo llamado modelo dual. 

En el modelo cliente-servidor, la generación de la interfaz de usuario y gran parte de la lógica de la aplicación está separada de la gestión de los datos. 

Para una aplicación desarrollada usando SQL, esto significa que el cliente genera los comandos SQL y el servidor los ejecuta. Esta es la división básica cliente-servidor, que por regla general cuenta con una red de área local entre los dos lados. 

El protocolo de comunicaciones de la red utilizado entre el proceso de usuario y el proceso del servidor es el protocolo propietario de Oracle, Oracle Net.

El cliente lo forman dos componentes: los usuarios y los procesos de usuario. 

El servidor tiene tres componentes: los procesos del servidor que ejecutan el SQL, la instancia, y la propia base de datos. 

Cada usuario interactúa con un proceso de usuario. Cada proceso de usuario interactúa con un proceso del servidor, normalmente a través de una red de área local. 

Los procesos del servidor interactúan con la instancia y la instancia con la base de datos. 

La siguiente figura muestra esta relación en forma de diagrama.

Anotaciones-hibernate

Anotaciones a nivel de clase:

@Entity
Establece la clase persistente.

@Table(name=“nombreTabla")
Configura características de la tabla donde se persiste la clase.

@MappedSuperclass
Determina la súper clase de una clase persistente.

@Embeddable
Determina la clase contenida en una clase persistente.

@Inheritance(strategy = estrategiaTipo)
Define el tipo de estrategia para persistir una jerarquía de herencia entre clases.

@DiscriminatorColumn
Define la columna (nombre y tipo de dato) utilizada como discriminante.

@DiscriminatorValue
Determina el valor para la columna utilizada como discriminador.

@PrimaryKeyJoinColumn(name=“nombreIdentificador")
Define el nombre de la clave relacionante.

Anotaciones a nivel de propiedades

@Id
Define la clave primaria.

@GeneratedValue
Establece el modo de asignación de los valores de la clave primaria.

@Column
Determina características de la columna de la tabla.

@Transient
Indica propiedad no persistente.

@Embedded
Indica que la propiedad es un objeto agregado.

@EmbeddedId
Indica que la clave primaria es por composición.

@PrimaryKeyJoinColumn
Define la clave primaria como relacionante.

@OneToOne
Asocia dos entidades en tablas distintas estableciendo vinculación única
entre ambas por medio de la clave primaria

@OneToMany
Asocia una entidad con una colección de otra entidad en tablas distintas
estableciendo vinculación referencial entre ambas

@ManyToOne
La asociación se establece en la entidad que es colección en la entidad
que la compone. Se genera vinculación referencial.

@ManyToMany
Son entre colecciones de entidades. Generan una tercera tabla
asociativa estableciendo una doble vinculación referencial.

Entidades persistentes

@Entity
@Table(name=“personas")
public class Persona {
          @Id
          @GeneratedValue( strategy = GenerationType.AUTO)
           private Integer id;

         @Column (name=“nombre", nullable=false, length=50)
         private String nombre;

         private String dni;
        @Transient private int estado;
}

Asociaciones uno a uno

@Entity
@Table(name="usuarios")
public class Usuario {

     @Id private Integer id;
     private String nombre;

     @OneToOne(cascade = CascadeType.ALL)
     private Domicilio domicilio;
}

        @Entity
        @Table(name="domicilios")
         public class Domicilio {

           @Id private Integer id;
           private String direccion;

           @OneToOne(mappedBy = "domicilio")
           private Usuario propietario
}

Como-cambiar-de-workspace

A continuación os detallo un breve manual, para cambiar de workspace, con el objetivo de probar la aplicación con otro repositorio de código. 

Es decir, la idea es que tengamos al menos dos workspaces, uno que apunte a la rama de desarrollo (APLICACION1-desa) y otro que apunte a la rama del trunk (trunk). 

La mayoría de las veces, trabajamos con la rama de desarrollo. Pero hay veces, que el error solo ocurre en el código del trunk, o para reproducir la incidencia hay que probarlo en la BBDD APLICACION1BACKUP (que está en el entorno de pruebas, y es un BACKUP de Producción de la semana), y para acceder desde el aplicativo, a esta BBDD se necesita hacerlo con el código del trunk. Porque en código de desarrollo, es probable que no esté nivelado con la BBDD, es decir, en la rama de desarrollo nos hayamos creado nuevas tablas / columnas, que no existen en esta BBDD y por lo tanto se producen errores.

Para cambiar de workspace, hay que realizar los siguientes pasos:

·       En eclipse, tener el servidor del workspace actual en start / debug.

·       Ir a la vista de servers, y pulsar con el botón derecho, seleccionado la opción add and remove. Ahí hay que quitar el war APLICACION1, teniendo marcada la opción de abajo (para que realice los cambios inmediatamente), como se adjunta en la imagen, y pinchar en Finish.

·        

·         Esto debería de quitar el war de APLICACION1, en la carpeta de despligue. Hay que confirmarlo que es así, se puede pinchar con el botón derecho sobre el servidor, seleccionando go to / admin console. Escribir “adminlocal” y password “adminlocal1”. Y una vez dentro, pinchar en despliegue y no debe aparecer la entrada de APLICACION1.

·        

·         En el Eclipse, pinchamos en File / Switch Workspace, seleccionamos el que queremos cambiar. 

      Hacemos un update sobre el repositorio, para tener los últimos fuentes, y un refresh sobre el proyecto, para que actualice los .class. Se cambia el config.properties para cambiar de BBDD, y ya debería de funcionar, levantar la aplicación en local. Importante, para acceder a APLICACION1BACKUP, hay que crearse este data source en la consola de weblogic, los datos son los mismos que los de pruebas / formación, pero en el usuario y contraseña hay que poner “APLICACION1BACKUP”. (para acceder al esquema APLICACION1BACKUP)

·         Cuando hayamos terminado con el workspace, y nos queramos cambiar a otro, hay que hacer la misma operación, que se ha realizado anteriormente( es decir, arrancar el servidor, y quitar el despliegue de APLICACION1)

Todo está operativa, se realiza, porque el war se llama igual, trabajando con un workspace que otro, y si no hacemos lo anterior, nos dice que al publicar APLICACION1 en el servidor que no puede,  porque el código del war instalado es de una ruta y nosotros ahora estamos instalando el war generado con otra ruta de fuentes.

Eclipse - Commit y merge de cambios en el código de un proyecto

COMMIT y MERGE DE LOS CAMBIOS EN EL CÓDIGO DE UN PROYECTO

Lo primero de todo, a primera hora de la mañana de forma diaria, deberíamos hacer un update sobre la rama de desarrollo y refrescar el proyecto en el Spring Tool Suite (Eclipse), para trabajar con los fuentes lo más actualizados posibles, para evitar problemas futuros.

No os preocupéis si tenéis cambios en local que todavía no están subidos, la herramienta los respeta sin ningún problema.

Luego en la rama de desarrollo: antes de realizar  commit de código relacionado con cambios en el modelo de base de datos, como la creación o modificación de tablas,  hay que ejecutar obligatoriamente los scripts que  modifican el modelo de datos en todos los entornos de prueba

Porque dichos entornos tiran de la rama de desarrollo, y si hay algún cambio en el modelo reflejado en el código, si no está actualizado en la BBDD da error.

Muy importante: Al hacer el commit en la rama de desarrollo (antes hay que hacer un update para que tengamos el repositorio actualizado), hay que poner en la descripción de la revisión; #Código de modificación – título de la modificación. EL #Código de modificación, es para que en la herramienta colaborativa se vincule la revisión subida a la tarea asociada y además cuando tengamos que hacer un merge de una tarea a la rama del trunk, saber localizar fácilmente que revisión / revisiones hay que seleccionar.

Por cada fichero que se vaya a realizar un commit, pulsar antes sobre el propio fichero con el botón derecho, y pulsar en la opción “Compare with base”, donde nos muestra las diferencias entre nuestro fichero y el ultimo que esta subido al subversión. Y ahí debe estar todos nuestros cambios y asegurarnos que no haya nada de código para realizar pruebas, etc.. Todo esto también hay que hacerlo al hacer un merge a la rama del trunk, en esta fase, ha ocurrido varias veces que se fusione código de otros compañeros que no debe subir, por lo cual hay que tener especial cuidado a la hora de revisar los cambios que se suben.

Los commit en la rama de desarrollo, solo se deben hacer cuando la tarea está terminada, o está en una versión estable y alguien o nosotros mismos la queremos probar en un entorno diferente al local.

En la lista de ficheros para hacer el commit; nos saldrán siempre o casi siempre los ficheros config.properties y weblogic.xml. Estos ficheros nunca hay que hacer commit, ni en la rama de desarrollo ni en la del trunk, estos se editan en nuestro local para que nos funcione nuestro servidor local de weblogic.       

Para hacer la fusión / merge al trunk del código fuente, hay que hacer lo siguiente;

·         posicionarse en la carpeta trunk, botón derecho TortoiseSVN / update. Para tener actualizado el repositorio y que de los menos conflictos posibles

·         En la carpeta trunk, boton derecho TortoiseSVN / Check for modifications. Para comprobar que no tengamos ningún fichero con cambios previamente, aquí solo deben de aparecer siempre como mucho los ficheros (config.properties y weblogic.xml)

·         En la carpeta trunk,  botón derecho TortoiseSVN / merge. En el campo URL to merge from, hay que seleccionar la carpeta desarrollo, y luego hay que pulsar en el botón show log, para seleccionar las revisiones que tenemos que mezclar (puede que no aparezcan todas, hay que pulsar en el botón show all, que esta abajo a la izquierda). Se seleccionan si hay varias, pinchando en la primera, y con el control pulsado seleccionar la última, y le damos al ok. Y luego next para que empiece a hacer el merge. Si hay algún conflicto de código la herramienta nos avisa y hay que resolverlo en ese mismo momento.

·         En la carpeta trunk,  botón derecho TortoiseSVN / commit. Pero antes de pulsar OK, hay pulsar por cada fichero que subamos, con el botón derecho sobre la opción “Compare with base”, y aquí comprobar que solo suben nuestros cambios y se han mezclado correctamente (mucho cuidado, algunas veces nos ha pasado que no lo ha hecho bien la herramienta, aunque no haya dado conflictos previamente).

·         Ahora vamos a buscar algunos posibles conflictos que no se han resuelto correctamente ó que el cliente del subversión no nos haya avisado del conflicto. Este caso que se ha producido en alguna ocasión, donde es más problemático en los jsp´s. Porque en los java, da error de compilación y nos enteraríamos al construir el war (con mvn clean package). Por este motivo, para que podamos revisarlo, debemos hacer el siguiente procedimiento;

o   abrir herramienta notepad++

o   en buscar / buscar en archivos, escribimos los siguiente:

§  <<<<<<< .mine

§  D:\NOMBRE_PROYECTO\trunk\fuentes\src\main\webapp\WEB-INF\views\app (donde vosotros tengáis los jsp´s del proyecto)

§  *.jsp, para que busque solo en los jsp´s

o   Si aparece el texto en algún jsp´s hay que corregirlo, si el error es nuestro, y si es de otro compañero, pues le avisamos.

·         Ahora hay que asegurarse que compila el proyecto, para ello se puede hacer la siguiente operativa;

o   Ir al explorador de Windows a la carpeta “D:\NOMBRE_PROYECTO\trunk\fuentes”, y escribir en la barra de dirección, la palabra cmd. Con esto, nos abre una consola de MS-Dos

o   Escribir  “mvn clean package -Dmaven.test.skip=true” y pulsar enter. Con esto intenta construir el proyecto, y al final si da resultado success, es que compila todo y podemos continuar con el siguiente paso.

·         A la hora de subir los ficheros, hay que desmarcar siempre los ficheros (config.properties y weblogic.xml), porque estos ficheros nunca deben de subir, puesto que tienen cambios para que nos funcione nuestro servidor de local.

·         Cuando tengamos todos los ficheros revisados y sabemos que compila el proyecto, hay que poner como descripción de la revisión lo siguiente:

·         en su lugar hay que pinchar en el botón “Recent messages” y pinchar en la primera descripción. Dicha descripción es la que pone subversión por defecto, cuando se realiza el merge. Y ahí se detalla mucho más la descripción; estableciendo las revisiones que estamos mergeando, junto con el código de tarea y su descripción. Por favor, revisad que la descripción es la correcta.

·         Por último, pulsar el botón ok, para que realice el commit definitivamente.

También puede ocurrir el siguiente escenario; hay que añadir un campo obligatorio a una tabla ya existente, el desarrollador para hacer pruebas tiene que crear el campo que permita nulos, para que no de ningún problema a ningún otro desarrollador. Y cuando tenga el código terminado y realice un commit, ya se podría cambiar en BBDD el campo a obligatorio. Porque el resto de desarrolladores con hacer un update sobre el subversión ya tendría los nuevos cambios en el código.