Kurs · Schulung · Workshop
Clean Code mit Java
Zwei Tage hands-on: Java-Code mit treffenden Namen, Value Objects, Optional und funktionalen Elementen lesbar machen, Legacy Code mit Characterization Tests absichern und test-first weiterentwickeln.
Java-Anwendungen leben lange. Über die Jahre sammeln sich Services mit zu vielen Aufgaben, Datenklassen aus Gettern und Settern, Null-Prüfungen an jeder zweiten Stelle und Methoden, die niemand mehr ganz überblickt. Dieser Kurs zeigt Java-Teams, wie sie solchen Code Schritt für Schritt verbessern. Die Teilnehmenden klären Namen und Abstraktionsebenen, erkennen Code Smells und refaktorieren mit den automatisierten Refactorings von IntelliJ IDEA. Sie wägen Duplikation gegen verfrühte Abstraktion ab, verbinden objektorientiertes Design mit funktionalen Elementen, ersetzen Getter und Setter durch Verhalten, flachen Bedingungen mit Optional ab und führen Value Objects für primitive Datentypen ein. Dazu kommen null-sichere Programmierung, Exception Handling, eigene Collection-Erweiterungen, Dependency Injection und Test-Driven Development. Geübt wird im Pair an Java-Projekten mit Maven und JUnit 5, ergänzt durch zwei Katas zu Legacy Code und Object Calisthenics. Der Kurs gehört zur Clean-Code-Familie von letsboot mit einem gemeinsamen Massstab: Code, den das Team lesen, gefahrlos ändern und testen kann. Für Teams mit mehreren Sprachen gibt es Clean Code Hands-On, für .NET Clean Code mit C#, für das Frontend Clean Code mit TypeScript, und wer die Struktur einer ganzen Spring-Boot-Anwendung angehen will, findet das in Clean Architecture mit Spring Boot. Am Ende haben die Teilnehmenden jede Technik an eigenem Übungscode angewendet und eine Checkliste für ihr Team.
Stimmen unserer Teilnehmer:innen






Diese Kunden haben Kurse im gleichen Themen-Cluster bei uns gebucht.Mehr Kunden →
Inhalt
Der Kurs richtet sich an Java-Teams, die bestehende Anwendungen warten und weiterentwickeln. Geübt wird im Pair in IntelliJ IDEA an Maven-Projekten mit JUnit 5.
Der Kurs besteht aus den folgenden Themen und kann je nach Publikum angepasst werden.
Naming, Abstraktion und Code als Kommunikation
- Namen für Variablen, Methoden, Klassen und Konstanten, Magic Numbers
- Naming als Prozess: die sieben Stufen vom fehlenden zum treffenden Namen
- Die passende Abstraktionsebene finden
- Code als Geschichte: für wen Code geschrieben wird
- Hands-On: Namen und Abstraktionsebenen in einem Java-Beispiel verbessern
Refactoring und Lean Code
- Cognitive Load als Treiber für Refactoring
- Kategorien von Code Smells und passende Heuristiken
- Lean Code und Just-Enough-Design
- Automatisierte Refactorings in IntelliJ IDEA
- Hands-On: Spot the Smell und geführtes Refactoring einer Java-Methode im Pair
Designstrategien und Prinzipien
- Balance zwischen spezifischem und abstraktem Code
- Reification: implizite Konzepte als eigene Typen sichtbar machen
- DRY, WET und AHA: verfrühte Abstraktion vermeiden
- Hands-On: ein Task-Management-System mit Reification refaktorieren
OOP und funktionale Programmierung
- Rich Domain Objects: Daten und Verhalten zusammenführen
- SOLID und Law of Demeter
- Do or Die Principle (DOD)
- Reine Funktionen für Berechnungen, Objekte für Verantwortung
- Hands-On: prozeduralen Payment Flow in Klassen und reine Funktionen aufteilen
Null-sichere Programmierung und die Stepdown Rule
- Strategien für Null-Sicherheit und wie man eine davon wählt
- Optional und Null Object Pattern
- Die Stepdown Rule: Methoden von oben nach unten lesen
- Hands-On: eine Klasse null-sicher umbauen
Eleganter und ausdrucksstarker Code
- Von Daten zu Verhalten: Getter durch Queries, Setter durch Domain-Methoden ersetzen
- Verschachtelte Bedingungen mit Optional abflachen
- Guard Clauses und kleine Methoden
- Hands-On: den Messy Booking Processor in ausdrucksstarke Domain-Objekte umbauen
Object Design und Primitive Obsession
- Elegant Objects: klein, unveränderlich, mit Verhalten
- Primitive Obsession erkennen, Value Objects einführen
- Mutation und Immutability, unveränderliche Collections
- Hands-On: ein Address Value Object mit Validierung und Geschäftsregeln bauen
Exception Handling, Datenklassen, Collections und Dependency Injection
- Exceptions einheitlich behandeln, Pluggable Exception Handling
- Datenklassen mit Verhalten entwerfen
- Collection-Logik in eigenen Typen kapseln, Beispiel Eclipse Collections
- Dependency Injection: fest verdrahtete Abhängigkeiten auflösen
- Hands-On: eine eigene Collection-Erweiterung mit filterAdmins, findActiveUsers und sortByLastLogin schreiben
Test-Driven Development und Legacy Code
- Red, Green, Refactor und der Unterschied zu Test After
- Characterization Tests mit ApprovalTests als Sicherheitsnetz
- Object Calisthenics als Übungsregeln, geprüft mit PMD
- Hands-On: Legacy Code Prime Printer Kata und Object Calisthenics LCD Numbers Kata
Am Ende haben die Teilnehmenden jede Technik an Java-Code geübt und eine Clean-Code-Checkliste für ihr Team erstellt. Arbeitet euer Team in mehreren Sprachen? Dann passt Clean Code Hands-On. Für die Struktur ganzer Anwendungen mit Use Cases, Ports und Modulen gibt es Clean Architecture mit Spring Boot.
Der effektive Kursinhalt kann, abhängig von Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen, von obigen Angaben abweichen.
In-House Kurs anfragen
Öffentlichen Termin anfragen
Kein passender öffentlicher Termin dabei? Trag dich unverbindlich ein – sobald genug Interesse besteht, planen wir einen neuen öffentlichen Termin und informieren dich zuerst.
Mehr über Clean Code mit Java
Clean Code in Java verbindet die Prinzipien aus dem Buch von Robert C. Martin (2008, zweite Auflage 2025) mit den Mitteln der Sprache. Seit Java 8 gehören Lambdas, Streams und Optional dazu, neuere Versionen bringen mit Records, Sealed Classes und Pattern Matching weitere Bausteine für Value Objects und ausdrucksstarken Code mit. Joshua Blochs «Effective Java» und die Ideen der Elegant Objects prägen bis heute, wie Java-Teams über Object Design sprechen.
Weitere Ressourcen:
Verwandte Kurse
- Clean Code Hands-On: sprachneutral, für Teams mit mehreren Sprachen
- Clean Architecture mit Spring Boot: Use Cases, Ports und Module für ganze Anwendungen
- Clean Code mit C#: dieselben Prinzipien für .NET-Teams
- Clean Code mit TypeScript: das Typsystem als Werkzeug für sauberen Code

