Autentia

Novedades Java 8 y 9

Objetivos

Java ha experimentado grandes cambios en sus últimas versiones. En este curso, haremos una puesta al día en las características de éstas últimas versiones de Java, empezando por los importantes cambios de la versión 8 y completandolo con las mejoras y nuevas funcionalidades de la versión 9.

  • Dominar la sintaxis de las lambdas y utilizarlas de forma adecuada para parametrizar comportamiento y mejorar la legibilidad y mantenibilidad del código
  • Utilizar los Streams para recorrer, operar, transformar y aplicar acciones a un conjunto de datos.
  • Conocer los cambios en la gestión de memoria y cómo configurar la JVM para obtener el mejor rendimiento.
  • Desarrollar aplicaciones basadas en módulos utilizando el estándar de JigSaw.
  • Ampliar los contratos basados en interfaces a través de métodos por defecto, privados y estáticos.
  • Crear de forma sencilla colecciones inmutables
  • Conocer los cambios en la gestión de memoria y cómo configurar la JVM para obtener el mejor rendimiento.

¿A quién va dirigido?

El curso está destinado a desarrolladores Java que tengan conocimientos previos y experiencia con el lenguaje Java y quieran conocer y profundizar en las nuevas características del lenguaje y las nuevas especificaciones de las versiones 8 y 9.

Contenidos

1. JSR-310. El nuevo API de Fecha y Hora de Java 8.

  • Los problemas tradicionales de la gestión de fechas en Java.
    • Date, Timestamp y Calendars.
  • JSR310.
    • Principios de diseño.
    • Clases principales.
      • Fechas, Horas y TimeZones.
      • Periodos y Duraciones.
    • Ejemplos.

2. Cambios en los interfaces en Java 8 y 9.

  • Interfaces como contratos.
  • Interfaces en Java 8: Métodos por defecto y estáticos.
  • Interfaces en Java 9: Métodos privados.
  • Casos de uso.
    • Evolución de contratos.
    • @FunctionalInterface (SAM Types).
    • Herencia múltiple, traits y mixins.
    • El problema del diamante. Resolución de conflictos.

3. Lambdas.

  • @FunctionalInterface y descriptores funcionales.
  • Sintaxis de las Lambdas.
  • Clases anónimas vs Lambdas.
  • Inferencia de tipos en las Lambdas.
  • ¿Son closures las Lambdas?
  • Tipología de las Lambdas por su contexto.
  • De la Lambda a Method References.
  • Casos de uso.
    • Programación funcional con Java.
    • Patrones de creación.
    • Gestión y cierre de recursos.
    • Pruebas unitarias.

4. Streams y Collections.

  • Métodos de factoría para las Collections en Java 9.
  • Streams vs Collections.
  • Características del Stream.
  • Programación Imperativa vs Declarativa.
  • Anatomía de un Stream.
  • Creación de Streams.
    • Colección.
    • Generadores.
    • Clases específicas.
    • Nullables (Java 9).
  • Operaciones intermedias (construcción del pipeline).
    • Operaciones sin estado.
    • Operaciones con estado.
  • Ejecución del Stream: Operaciones terminales.
    • Colectores.
    • Reductores.
    • Iteradores.
  • Un ejemplo: Registro de llamadas.
  • Rendimiento de los Streams.
  • Boxing y autoboxing. Streams de tipos primitivos.
  • Depurando Streams.
  • Ejecución de Streams en paralelo.
    • Creación de Parallel Streams.
    • Modelo de ejecución paralelo: Common ForkJoinPool.
    • Ventajas y peligros.
  • Mejoras de los Streams en Java 9.

5. Optionals.

  • Diseño del Optional.
  • Casos de uso.
  • Cuándo no utilizarlo.
  • Optionals de Stream.
  • Uso de Optionals en Streams.

6. Soporte para programación reactiva en Java 9.

  • Componentes Flow API.
  • Implementaciones.
  • Interoperabilidad entre implementaciones.
  • Streams y Reactive Streams.

7. Concurrencia.

  • Evolución de la concurrencia en Java.
  • Actualización de mecanismos de concurrencia
    • Lock y StampedLock.
    • CompletableFuture y soporte para programación asíncrona.
  • Mejoras de CompletableFuture en Java 9.

8. El camino hacia la modularidad en el JRE.

  • Aligerando el JRE: Compact Profiles de Java 8.
  • Jigsaw. La modularidad en Java 9
    • Un poquitín de Historia. Del JEP 200 al JSR 376.
    • Cambios en la estructura del JDK 9.
    • Objetivos y ámbitos de la modularidad.
    • El Big Kill Switch de Jigsaw.

9. Modularidad en Java 9.

  • Introducción y conceptos.
    • Módulos.
    • Dependencias.
    • Encapsulación y visibilidad.
    • Accesibilidad.
  • Creando módulos.
    • Estructura de los módulos.
    • Nombrado de módulos.
    • Tipología de módulos.
      • Explícitos.
      • Automáticos.
    • Rutas de los módulos.
    • Dependencias entre módulos.
    • Compilado, empaquetado y ejecución.
    • Soporte al testing de módulos.
    • Soporte en herramientas de construcción.
      • Maven, Gradle, IDEs.
  • Patrones de modularidad.
    • Servicios.
    • Ocultado de implementación.
    • Límite de los módulos.
    • Módulos como API.
    • Módulos de agregación.
    • Encapsulado de recursos.
    • Versionado de módulos.

10. Migrando de librerías a módulos.

  • Módulos automáticos.
  • El ClassPath y los Classloaders.
  • El ClassPath y el ModulePath.
  • Tipos y APIs afectadas.
  • Estrategias de migración.
  • Migración de librerías.

11. Reflexiones sobre modularidad.

  • Jigsaw vs OSGi vs Microservices

¿Quieres más información?

HABLEMOS