Design Patterns în Java Modern: aplici GoF și funcționalități Java 8+ pentru design curat.
Hands‑on cu pattern‑uri de creare, structurale și comportamentale.
Valorifici streams, lambda și functional interfaces pentru a moderniza codul.
Dobândești experiență practică prin laboratoare de refactoring și proiecte extensibile.
Cum te ajută: îmbunătățești mentenabilitatea, lizibilitatea și scalabilitatea aplicațiilor Java.
Cui i se adresează: conceput pentru persoane cu cunoștințe Java care caută skill‑uri mai bune de design.
Include opțional alternative moderne și anti‑patterns.
Curriculum
Ziua 1 — Fundamente & Creational
- Modern Java pentru patterns: records, sealed classes, pattern matching (instanceof/switch), var, modules (JPMS)
- Generics și variance; imutabilitate; equals/hashCode/toString; bune practici Optional
- Factory Method — intent, UML, implementare TDD; variantă cu switch pe enum; pattern matching switch
- Abstract Factory — familii de obiecte; compoziție vs. reflection; conectare prin modules
- Builder — fluent API; obiecte imuabile cu records; validare și staged builders
- Prototype — strategii de copiere; deep vs. shallow; copy constructors vs. serialization; records & withers
- Singleton — enum-based, lazy holder; testare și lifecycle; evitarea stării globale ascunse
Ziua 2 — Structural
- Adapter — class vs. object adapters; maparea API-urilor legacy; default methods ca adaptoare
- Bridge — decuplarea abstracție/implementare; când preferăm compoziția
- Composite — tratament unitar al part/whole; variante safe vs. transparent; iterare cu streams
- Decorator — stratificarea comportamentului; diferențe vs. moștenire; records pentru decoratori mici
- Facade — simplificarea subsistemelor; granițe de modul și trucuri de vizibilitate în package
- Flyweight — partajare memorie; interning; value-based classes; capcane cu mutabilitatea
- Proxy — static vs. dynamic proxies; caching, securitate, remote; virtual proxy cu lazy loading
Ziua 3 — Behavioral & Concurrency
- Strategy — înlocuirea condiționalelor; lambdas/functional interfaces; compunere de strategii
- Template Method — hooks vs. default methods; când îl înlocuim cu Strategy
- State — ierarhii sealed pentru stări explicite; tabele de tranziții
- Chain of Responsibility — pipelines; rezultate Optional/Try-like; lanțuri bazate pe streams
- Command — undo/redo; cozi și audit logging; obiecte command funcționale
- Observer — Flow API/Reactive Streams; property change; noțiuni de backpressure
- Mediator — reducerea cuplării în GUI/module; event bus
- Iterator — Iterable vs. Stream; colectare și lazy; Spliterator custom
- Memento — snapshot-uri cu records; hooks pentru persistență
- Visitor — ierarhii sealed; pattern matching switch; alternative la double-dispatch
- Interpreter — mini DSL-uri; parsing cu pattern matching; când preferăm combinatoare
- Addendum de concurență — executors vs. virtual threads; CompletableFuture; structured concurrency (concepte)
Module opționale
Opțional — Arhitecturi & testare
- Dependency Injection (Jakarta CDI/Spring) — relația cu patterns (Factory, Strategy, Facade)
- Hexagonal/Ports & Adapters; straturi și granițe de modul (JPMS)
- Testarea pattern-urilor cu JUnit 5; test doubles; approval tests pentru refactorizări
Structura zilei de curs
- 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