Curso de Java

Tipos primitivos y operadores con casos reales

Variables, alcance y mutabilidad con ejemplos claros

Condicionales y legibilidad en reglas de negocio

Bucles y patrones de iteración habituales

Métodos: firmas, parámetros y valores de retorno

Sobrecarga y decisión de diseño

Entrada y salida básica por consola

Diseño de funciones pequeñas y comprobables

Errores comunes de principiantes y cómo evitarlos

Lectura de código: entender antes de escribir

Clases, objetos y responsabilidad única

Campos, constructores y control de invariantes

Encapsulación con getters y setters con criterio

Inmutabilidad práctica y efectos en el diseño

Métodos de instancia vs estáticos con ejemplos

Equals, hashCode y toString para objetos de dominio

Paquetes y visibilidad para modularidad

Composición frente a herencia como regla base

Patrones simples para modelar entidades y servicios

Refactorización inicial: de script a modelo

Herencia: cuándo aporta valor y cuándo no

Polimorfismo para eliminar condicionales frágiles

Interfaces como contratos estables

Clases abstractas y plantillas de comportamiento

Implementaciones múltiples y separación por roles

Principio LSP explicado con ejemplos sencillos

Inyección por interfaz en código cotidiano

Reglas de diseño para extensibilidad

Modelado de catálogos y estrategias simples

Prácticas de revisión para evitar jerarquías inútiles

Genéricos y seguridad de tipos en colecciones

List: usos típicos y coste mental de mutabilidad

Set: unicidad y deduplicación controlada

Map: diccionarios, claves y valores con criterio

Comparación y ordenación con Comparator

Iteración segura y modificaciones durante recorrido

Errores típicos con null y estructuras vacías

Elección de estructura según caso de uso

Conversión entre colecciones de forma limpia

Diseño de APIs que devuelven colecciones coherentes

Lambdas y referencias a métodos con claridad

Stream pipeline: map, filter, reduce

Collectors para agrupar, contar y transformar

Optional como herramienta de intención

Evitar abuso de streams en lógica compleja

Side effects y cómo detectar código peligroso

Lectura y depuración de pipelines

Rendimiento básico y operaciones costosas

Diseño de transformaciones de datos de negocio

Estilo funcional compatible con revisiones de equipo

Diferencia entre errores de programación y de negocio

Checked vs unchecked y criterios de uso

Diseño de excepciones propias con mensajes útiles

Propagación y encapsulación de fallos

Try-with-resources y cierre seguro

Validaciones de entrada y precondiciones

Errores frecuentes y anti patrones de excepciones

Registro de errores sin filtrar datos sensibles

Estrategias de recuperación simples

Contratos de error claros en métodos públicos

Tipos de fecha y hora modernos en Java

Zonas horarias y errores habituales

Formateo y parseo con patrones controlados

Duraciones y periodos para cálculos de negocio

Comparaciones correctas y ordenación temporal

Normalización de entradas de fecha

Representación de timestamps en integraciones

Buenas prácticas para logs y auditoría

Evitar Date legado en código nuevo

Casos reales: vencimientos, ventanas y SLA simples

Rutas, directorios y permisos básicos

Lectura y escritura de texto con codificación correcta

Lectura y escritura binaria con casos simples

Gestión de ficheros grandes con streaming

Manejo de errores de E/S y recuperación

Serialización simple de datos para intercambio

Organización de ficheros por entorno y proyecto

Validación de contenido y tamaño

Buenas prácticas para no perder trazabilidad

Patrones de utilidades reutilizables

Qué es JSON y cómo modelarlo en clases

Serialización y deserialización con criterios claros

Validación de esquemas a nivel básico

Manejo de campos opcionales y compatibilidad

Llamadas HTTP básicas desde Java

Construcción de requests y headers

Manejo de respuestas y códigos de estado

Retries simples y control de tiempos

Errores típicos en integraciones

Buenas prácticas para no filtrar datos sensibles

Conceptos de tabla, clave y relaciones mínimas

Lectura de datos con queries simples

Escritura segura evitando concatenación peligrosa

Uso de parámetros y control de tipos

Gestión de conexiones y cierre correcto

Transacciones a nivel básico y consistencia

Mapeo manual a objetos de dominio

Errores comunes de rendimiento en consultas

Logging de consultas con cuidado

Estructura limpia para separar acceso a datos

Qué probar y qué no probar en Java

Estructura AAA y nombres de test útiles

Asserts claros y mensajes accionables

Dobles de prueba: stubs y mocks con moderación

Pruebas de excepciones y validaciones

Cobertura como señal, no como objetivo

Refactor guiado por tests

Gestión de datos de prueba

Integración de tests en build local

Buenas prácticas para suites rápidas y fiables

Separación por capas a nivel básico

DTOs y modelos de dominio sin mezclar responsabilidades

Principios SOLID en decisiones concretas

Evitar “clases dios” y servicios monstruosos

Nombres, cohesión y acoplamiento medible

Refactorización incremental sin romper funcionalidad

Gestión de configuraciones por entorno

Manejo de constantes y enums con criterio

Errores de diseño típicos en proyectos junior

Reglas de revisión para equipos

Qué es un hilo y cuándo importa

Problemas típicos: race conditions y visibilidad

Uso de ejecutores a nivel básico

Tareas simples en paralelo con control

Colecciones concurrentes a nivel conceptual

Evitar bloqueos innecesarios

Timeouts y cancelación simple

Riesgos de concurrencia en acceso a datos

Buenas prácticas para código predecible

Cuándo no usar concurrencia todavía

Logs con niveles y estructura consistente

Trazas de ejecución y diagnóstico rápido

Manejo de IDs de correlación a nivel básico

Medición simple de tiempos de ejecución

Errores frecuentes en logs que dañan producción

Separación de logs técnicos y de negocio

Preparación para análisis posterior

Configuración local reproducible

Buenas prácticas para depurar incidencias

Documentación mínima del comportamiento

Estructura de repositorio y convenciones

Ramas y commits con mensajes útiles

Revisión de cambios y criterios de calidad

Resolución de conflictos típica en Java

Gestión de dependencias en PRs

Versionado semántico a nivel conceptual

Etiquetado y releases básicos

Uso de plantillas de PR y checklist técnica

Automatización mínima de tests en CI

Buenas prácticas para trabajo colaborativo

Definición de un dominio y casos de uso claros

Modelado de entidades y reglas con POO

Persistencia básica y acceso a datos

Importación y exportación simple en JSON

Lógica de negocio con validaciones coherentes

Gestión de errores con mensajes profesionales

Pruebas unitarias para los casos críticos

Registro de operaciones relevantes

Documentación mínima para mantenimiento