Java entwickelt sich seit dem Wechsel auf den Sechs-Monats-Release-Zyklus in einem Tempo, das kaum jemand vollständig im Blick behält. Zwischen Java 11 und Java 25 liegen Records, Sealed Classes, Virtual Threads, Pattern Matching, Stream Gatherers, Scoped Values, AOT-Kompilierung und vieles mehr – Features, die die Art, wie man Java schreibt und betreibt, grundlegend verändern.
Du hast die Wahl:
- Modul 1 – Java 12 bis 17 (1 Tag, einzeln buchbar): Records, Sealed Classes, Pattern Matching für instanceof, Switch Expressions und Text Blocks.
- Modul 2 – Java 18 bis 21 (2 Tage, einzeln buchbar): Virtual Threads (inkl. Pitfalls und Observability), Pattern Matching für switch, Record Patterns und Sequenced Collections.
- Modul 3 – Java 22 bis 25 + Ausblick Java 26 (2 Tage, einzeln buchbar): Scoped Values, Structured Concurrency, Stream Gatherers, AOT, FFM API und die aktuellsten Sprachneuerungen.
- Alle drei Module als Gesamtpaket (5 Tage): Der vollständige Pfad von Java 12 bis 25.
Dieses Training bringt erfahrene Java-Entwickler:innen systematisch auf den aktuellen Stand. Kein oberflächlicher Überblick, sondern ein durchdachter Aufbau: Die drei Module bauen aufeinander auf, die Sprachfeatures werden in sinnvollen Kombinationen vermittelt, und jeder Block endet mit einer praktischen Übung. Du verlässt das Training nicht nur mit Wissen, sondern mit dem Handwerkszeug, um moderne Java-Features in realen Projekten einzusetzen – und um fundierte Entscheidungen bei der Migration deiner Anwendungen zu treffen.
Agenda
Modul 1 – Java 12 bis 17
- Switch Expressions + Text Blocks + Helpful NullPointerExceptions
- Records + Pattern Matching für instanceof
- Sealed Classes + API-Highlights
- GC, Performance, Strong Encapsulation + Migration
Modul 2 – Java 18 bis 21
Tag 1
- Virtual Threads: Architektur und API
- Virtual Threads: Praxis und Pitfalls
- Observability & Virtual Threads
- Pattern Matching für switch
Tag 2
- Record Patterns + Kombinationspower
- Sequenced Collections + API-Erweiterungen
- GC, Performance & weitere Themen
- Deprecations + Migration + Wrap-up
Modul 3 – Java 22 bis 25 + Ausblick Java 26
Tag 1
- Compact Source Files + Module Imports + Multi-File Programs
- Markdown Javadoc + Unnamed Variables & Patterns + Flexible Constructors
- Stream Gatherers
- Project Loom: Scoped Values
Tag 2
- Project Loom: Structured Concurrency
- Performance & GC
- FFM API + Integrity by Default + Cryptography
- Kleinere API-Erweiterungen + Ausblick Java 26 + Wrap-up
Dein Nutzen
Verstehe, welche Features aus Java 12–25 deinen Alltag als Entwickler:in sofort verbessern – und setze sie sicher ein.
Migriere Anwendungen von Java 11 über 17 und 21 bis nach 25 mit einer klaren Strategie und Kenntnis der Breaking Changes.
Nutze Virtual Threads korrekt: mit Verständnis für Architektur, Pitfalls und Observability – statt mit halbgarem Copy-Paste.
Modelliere Domänen mit Records, Sealed Classes und Pattern Matching präzise und ausdrucksstark – direkt in Java.
Schreibe besseren, lesbareren Code durch Records, Pattern Matching, Text Blocks, Unnamed Variables und Stream Gatherers.
Wähle den richtigen Garbage Collector für deinen Anwendungsfall und verstehe, was sich seit Java 11 in der GC-Landschaft verändert hat.
Verkürze Startzeiten mit AOT Class Loading und verstehe, wie Project Leyden JVM-Start und Warmup grundlegend verbessert.
Ersetze ThreadLocal durch Scoped Values und gestalte nebenläufige Anwendungen mit Structured Concurrency strukturiert und fehlertolerant.
Zielgruppe
Dieses Training richtet sich an erfahrene Java-Entwickler:innen, die aktiv auf einer Java-11- oder Java-17-Codebasis arbeiten und auf den aktuellen Stand kommen wollen. Auch Entwickler:innen, die bereits auf Java 21 sind und den Sprung in Richtung Java 25 vorbereiten, werden in Modul 3 genau das Richtige finden. Vorausgesetzt wird solides Java-Grundwissen; die Features der jeweils behandelten Java-Versionen werden dagegen von Grund auf eingeführt – kein Vorwissen dazu nötig.
Wer nur einzelne Module bucht, sollte die Voraussetzungen beachten: Modul 2 setzt Vertrautheit mit den in Modul 1 behandelten Sprachfeatures (Records, Sealed Classes) voraus; Modul 3 baut auf dem Virtual-Threads-Fundament aus Modul 2 auf.
Lernziele
Neue Sprachfeatures von Java 12–25 sicher anwenden
Boilerplate-Code durch Records, Pattern Matching und moderne API-Methoden gezielt reduzieren
Domänenmodelle mit Sealed Interfaces und Records als algebraische Datentypen ausdrücken
Virtual Threads verstehen, korrekt einsetzen und mit geeigneten Tools beobachten und debuggen
ThreadLocal durch Scoped Values ersetzen und nebenläufige Aufgaben mit Structured Concurrency strukturiert koordinieren
GC-Neuerungen von Java 12–25 einordnen und den passenden Garbage Collector für eigene Anforderungen wählen
AOT Class Loading und AOT Method Profiling einsetzen, um JVM-Startzeiten zu verkürzen
Deprecations und Breaking Changes von Java 11 bis 25 kennen und Migrationen strukturiert angehen
Native Bibliotheken mit der Foreign Function & Memory API sicher ansprechen – ohne JNI
Deine Trainer:innen
Falk Sippach
embarc
Architekturbewertungen, Java Experte
- Agile Softwarearchitektur
- Application Programming Interfaces
- CPSA Foundation-Level
- Documentation-as-Code
- Evolution und Verbesserung von Softwarearchitekturen
- Flexible Architekturen
- Modern Java Masterclass
- Phantastische Diagramme
- Spring Modulith
Als Trainer, Berater und Architekt ist Falk stets auf der Suche nach dem Funken Leidenschaft, den er bei seinenTeilnehmern, Kunden und Kollegen entfachen kann. Bereits seit über 15 Jahren unterstützt er in meist agilen Softwareentwicklungsprojekten im Java-Umfeld, anfangs als Entwickler, später als Projektleiter, Architekt und Coach. Falk ist überzeugt, dass lebenslanges Lernen die Voraussetzung für die berufliche Selbstentfaltung und dauerhafte Freude am Tun ist. Trotz der Begeisterung für Neues behält er immer auch die Menschen und gewachsene Strukturen im Blick, um ausgewogene Lösungen entwickeln zu können. Als aktiver Bestandteil der Community teilt er sein Wissen gern in Artikeln, Blog-Beiträgen sowie bei Vorträgen auf Konferenzen oder User Group Treffen und unterstützt bei der Organisation diverser Fachveranstaltungen. Video: Was ist eigentlich Documentation as Code? Falk erklärt es euch im Stream mit Lisa Moritz.
Sven Woltmann
HappyCoders, Java-Experte
Java
- Modern Java Masterclass
Sven Woltmann arbeitet seit über 30 Jahren mit Java – als Entwickler, Architekt, Trainer, Autor und Speaker. Mit HappyCoders.eu betreibt er einen der meistgelesenen Java-Blogs im deutschsprachigen Raum. Als Konferenz- und JUG-Speaker ist er bekannt dafür, auch anspruchsvolle technische Konzepte klar und praxisnah zu vermitteln. In seinen Trainings verbindet er tiefes technisches Verständnis mit langjähriger Projekterfahrung – mit dem Anspruch, dass das Gelernte sofort in der Projektpraxis angewendet werden kann.