Design Patterns in Modern Java: GoF‑Patterns und Java 8+ Features für sauberes Design anwenden.
Hands‑on mit Erzeugungs‑, Struktur‑ und Verhaltensmustern.
Streams, Lambdas und Functional Interfaces nutzen, um Code zu modernisieren.
Praktische Erfahrung sammeln durch Labs mit Refactoring und erweiterbaren Projekten.
Nutzen: Wartbarkeit, Lesbarkeit und Skalierbarkeit von Java‑Anwendungen verbessern.
Für wen: gedacht für Personen mit Java‑Kenntnissen, die besseres Design suchen.
Mit optionalem Teil zu modernen Alternativen und Anti‑Patterns.
Curriculum
Tag 1 — Grundlagen & Creational
- Modern Java für Patterns: Records, Sealed Classes, Pattern Matching (instanceof/switch), var, Module (JPMS)
- Generics und Varianz; Immutability; equals/hashCode/toString; Optional Best Practices
- Factory Method — Intent, UML, Test-First-Implementierung; Variante mit enum-switch; pattern matching switch
- Abstract Factory — familienbasierte Interfaces; Komposition vs. Reflection; Wiring via Module
- Builder — Fluent API; unveränderliche Objekte mit Records; Validierung und staged Builders
- Prototype — Kopierstrategien; deep vs. shallow; Copy-Konstruktoren vs. Serialization; Records & Withers
- Singleton — enum-basiert, Lazy Holder; Testbarkeit und Lifecycle; versteckten Global State vermeiden
Tag 2 — Structural
- Adapter — Klassen- vs. Objektadapter; Legacy-APIs abbilden; Default Methods als Adapter
- Bridge — Abstraktion/Implementierung entkoppeln; Komposition statt Vererbung
- Composite — Einheitsbehandlung von Teil/Ganzem; safe vs. transparent; Iteration mit Streams
- Decorator — Verhalten schichten; Unterschiede zur Vererbung; kleine Decorators mit Records
- Facade — Subsysteme vereinfachen; Modulgrenzen und Package-Visibility-Tricks
- Flyweight — Speichersharing; Interning; value-based classes; Fallstricke bei Mutabilität
- Proxy — statische vs. dynamische Proxies; Caching, Security, Remote; Virtual Proxies mit Lazy Loading
Tag 3 — Behavioral & Concurrency
- Strategy — If-Kaskaden ablösen; Lambdas/Functional Interfaces; Strategien komponieren
- Template Method — Hooks vs. Default Methods; wann durch Strategy ersetzen
- State — Sealed-Class-Hierarchien für explizite Zustände; Transitionstabellen
- Chain of Responsibility — Pipelines; Optional/Try-ähnliche Ergebnisse; Stream-basierte Ketten
- Command — Undo/Redo; Queueing und Audit Logging; funktionale Command-Objekte
- Observer — Flow API/Reactive Streams; Property Change; Backpressure-Grundlagen
- Mediator — Kopplung in GUIs/Modulen reduzieren; Event Bus
- Iterator — Iterable vs. Stream; Lazy und Collecting; eigener Spliterator
- Memento — Snapshots mit Records; Persistenz-Hooks
- Visitor — Sealed Hierarchien; Pattern-Matching-Switch; Alternativen zu Double-Dispatch
- Interpreter — kleine DSLs; Parsen mit Pattern Matching; wann Kombinatoren bevorzugen
- Concurrency-Addendum — Executors vs. Virtual Threads; CompletableFuture; Structured Concurrency (Konzepte)
Optionale Module
Optional — Architektur & Testing
- Dependency Injection (Jakarta CDI/Spring) — Bezug zu Patterns (Factory, Strategy, Facade)
- Hexagonal/Ports & Adapters; Schichten und Modulgrenzen (JPMS)
- Pattern-Tests mit JUnit 5; Test Doubles; Approval Tests für Refactorings
Kursablauf
- Part 1: 09:00–10:30
- Break: 10:30–10:45
- Part 2: 10:45–12:15
- Lunch break: 12:15–13:15
- Part 3: 13:15–15:15
- Break: 15:15–15:30
- Part 4: 15:30–17:30