Design-Prinzipien

SOLID im Überblick: fünf Prinzipien und die Dependency Inversion

SOLID fasst fünf Entwurfsprinzipien für objektorientierten Code zusammen: Single Responsibility, Open Closed, Liskov Substitution, Interface Segregation und Dependency Inversion. Ausführlich behandelt der Artikel das letzte: Du baust in der CSB-Rad-Kata den Bestellabschluss so um, dass er nur noch von Abstraktionen abhängt, unterscheidest Dependency Inversion, Inversion of Control und Dependency Injection und testest mit Stub und Mock. Zum Schluss findest Du mehrere Verstöße zugleich und legst fest, was Du zuerst umbaust.

Klassen schneiden: Single Responsibility, Separation of Concerns, Information Hiding, Tell, don’t ask und Law of Demeter

Eine Klasse, die rechnet, prüft, Mails verschickt und speichert, muss sich bei jeder Regeländerung mitändern. Du lernst, Klassen nach Verantwortungen zu schneiden (Single Responsibility Principle), Belange zu trennen (Separation of Concerns), Entwurfsentscheidungen zu verbergen (Information Hiding), Entscheidungen zu den Daten zu verlagern (Tell, don’t ask) und Getter-Ketten aufzulösen (Law of Demeter). Am Bestellabschluss der CSB-Rad-Kata beurteilst Du Kohäsion und Kopplung im UML-Klassendiagramm.

Methoden gliedern: Single Level of Abstraction, IOSP, eine Aufgabe je Methode und Fail fast

Eine gut gegliederte Methode liest sich wie ein Inhaltsverzeichnis: oben steht, was passiert, weiter unten, wie es passiert. Du lernst, Abstraktionsebenen in einer Methode zu erkennen und zu trennen (Single Level of Abstraction), Methoden in Integrationen und Operationen aufzuteilen (IOSP), jeder Methode genau eine Aufgabe zu geben, Parameterlisten kurz zu halten und Eingaben früh zu prüfen (Fail fast, Guard Clauses, Ausnahmen statt Fehlercodes). Am Bestellabschluss der CSB-Rad-Kata siehst Du, wie sich dadurch Methodenlänge, Verschachtelung und zyklomatische Komplexität verändern.

Übungsaufgaben zu SOLID und Dependency Inversion

Drei Übungsaufgaben zu SOLID: Du entkoppelst in der CSB-Rad-Kata den Bestellabschluss nach dem Dependency Inversion Principle und testest ihn mit Stub und Mock, findest im Erinnerungsdienst des Mitfahrlabors Verstöße gegen mehrere SOLID-Prinzipien, legst eine Reihenfolge für den Umbau fest und baust ihn mit fester Uhr im Test um, und nimmst Stellung zu der Frage, wann Dependency Injection zu viel ist.

Übungsaufgaben zum Erweitern statt Ändern: Open Closed Principle und Interface Segregation Principle

Drei Übungsaufgaben zum Erweitern statt Ändern: Du ersetzt im Mitfahrlabor eine Fallunterscheidung nach dem Fahrzeugtyp durch Polymorphie, baust in der CSB-Rad-Kata die Versandarten als Strategie um und ergänzt das Expresspaket, ohne den Bestellabschluss zu ändern, und teilst ein zu breites Interface des Mitfahrlabors nach den Rollen seiner Nutzenden auf, mit Klassendiagramm vor und nach dem Umbau.

Erweitern statt ändern: Open Closed Principle und Interface Segregation Principle

Jede neue Versandart verlangt im Bestellabschluss der CSB-Rad-Kata Änderungen an mehreren switch-Anweisungen. Mit dem Open Closed Principle kommen neue Varianten als neue Klassen dazu, ohne fertigen Code zu ändern: Fallunterscheidungen nach dem Typ werden zu Polymorphie mit einer Strategie hinter einem Interface. Das Interface Segregation Principle hält diese Interfaces schlank, was vor allem Tests mit Test-Doubles erleichtert. Du lernst auch, wann sich die Abstraktion nicht lohnt (YAGNI).

Übungsaufgaben zum Einsatz von Vererbung: Liskov Substitution Principle und Favour Composition over Inheritance

Drei Übungsaufgaben zum Einsatz von Vererbung: Du findest im Mitfahrlabor LSP-Verstöße bei den Benachrichtigungskanälen und behebst sie, baust in der CSB-Rad-Kata die Kurierzustellung ohne LSP-Verstoß ein und ersetzt eine Vererbungshierarchie aus Fahrtangebot, Mitfahrerliste und ArrayList durch Komposition, mit Klassendiagramm vor und nach dem Umbau.

Vererbung richtig einsetzen: Liskov Substitution Principle und Favour Composition over Inheritance

Vererbung spart Tipparbeit, kann aber Programme brechen, die mit der Oberklasse rechnen. Das Liskov Substitution Principle sagt, wann eine Unterklasse ihre Oberklasse ersetzen kann: Sie verlangt nicht mehr, verspricht nicht weniger und hält die Invarianten ein. Du erkennst typische Verstöße und die fragile Basisklasse und ersetzt Vererbung durch Komposition und Delegation, am Beispiel der Kurierzustellung der CSB-Rad-Kata und mit Blick auf Duck Typing in Python.

Übungsaufgaben zum Schneiden von Klassen: Single Responsibility, Separation of Concerns, Information Hiding, Tell, don’t ask und Law of Demeter

Vier Übungsaufgaben zum Schneiden von Klassen: Du zerlegst die Klasse Shop der CSB-Rad-Kata in Klassen mit je einer Verantwortung, löst im Mitfahrlabor Getter-Ketten mit Tell, don’t ask auf, zeichnest für die Fahrtenverwaltung ein Klassendiagramm vor und nach dem Umbau und trennst die Anzeige der Flurmonitore in Speicherung, Fachlogik, Darstellung und Protokollierung.

Übungsaufgaben zum Gliedern von Methoden: Single Level of Abstraction, IOSP, eine Aufgabe je Methode und Fail fast

Drei Übungsaufgaben zum Gliedern von Methoden: Du trennst im Bestellabschluss der CSB-Rad-Kata Integration und Operation und ziehst alle Prüfungen nach vorn, baust die Anfragebestätigung des Mitfahrlabors mit Guard Clauses, Ausnahmen und einem Parameterobjekt um und gliederst den Erinnerungsdienst so, dass er sich wie sein Aktivitätsdiagramm liest.

Übungsaufgaben zum Refactoring: Code Smells erkennen und in sicheren Schritten umbauen

Vier Übungsaufgaben zum Refactoring: Du ergänzt die Charakterisierungstests der CSB-Rad-Kata und zerlegst ihren Bestellabschluss mit „Methode extrahieren“ und einem Parameterobjekt, bringst Refactoring-Schritte für die Flurmonitor-Anzeige des Mitfahrlabors in eine sichere Reihenfolge, ordnest Code Smells passenden Refactorings zu und verfolgst einen Fehler bei den freien Plätzen mit dem 5-mal-Warum bis zur Ursache.

Refactoring: Code Smells erkennen und in sicheren Schritten umbauen

Refactoring verbessert die Struktur von Code, ohne sein Verhalten zu ändern. Damit das gelingt, brauchst Du ein Sicherheitsnetz aus Tests, kleine Schritte und einen Commit nach jedem grünen Testlauf. Du lernst typische Code Smells kennen, ordnest ihnen passende Refactorings zu und zerlegst die lange Methode der CSB-Rad-Kata mit „Methode extrahieren“ und einem Parameterobjekt. Dazu kommen die Werkzeuge der IDE und ihre Grenzen in Python, die Pfadfinderregel und die Ursachenanalyse mit dem 5-mal-Warum.

Übungsaufgaben zu einfachem Code: KISS, YAGNI, DRY und Beware of Premature Optimization

Fünf Übungsaufgaben zu einfachem Code: Du ordnest Verstöße gegen KISS, YAGNI, DRY und Beware of Premature Optimization in der Mitfahr-App Mitfahrlabor zu, unterscheidest echte Wissensdopplung von zufälliger Ähnlichkeit, räumst den Bestellabschluss der CSB-Rad-Kata von Stand 02 zu Stand 03 auf, führst eine kopierte Kostenbeitragsberechnung zusammen und wägst zum Schluss DRY gegen die Kopplung zweier Teams ab.

Einfach bleiben: KISS, YAGNI, DRY und Beware of Premature Optimization

Vier Prinzipien halten Code einfach: KISS (so einfach wie möglich), YAGNI (nur bauen, was heute gebraucht wird), DRY (jedes Wissen genau einmal) und Beware of Premature Optimization (erst messen, dann optimieren). An der Kata der CSB-Rad GmbH entfernst Du doppelte Berechnungen, einen ungenutzten Parameter und einen Zwischenspeicher, der nichts bringt. Dabei lernst Du auch die Grenzen kennen: Nicht jede Ähnlichkeit ist eine Dopplung, und manchmal ist Wiederholung das kleinere Übel.

Lesbarer Code: Konventionen, sprechende Namen, Kommentare und das Prinzip der geringsten Überraschung

Code wird viel öfter gelesen als geschrieben. Dieser Artikel zeigt an der Kata der CSB-Rad GmbH, wie Du Code mit wenigen Handgriffen lesbar machst: einheitliche Schreibweisen nach den Konventionen für Java und Python (PEP 8), sprechende Namen statt Abkürzungen, benannte Konstanten und Aufzählungen statt magischer Zahlen, Kommentare, die das Warum erklären, und Methoden, die tun, was ihr Name verspricht (Prinzip der geringsten Überraschung, Command-Query-Separation). Zum Schluss geht es um Linter und Formatierer, die einen Teil dieser Regeln automatisch prüfen.

Clean Code: Werte, Kopplung und Kohäsion, Code Smells, Prinzipien und Praktiken im Überblick

Code, der funktioniert, ist noch lange kein guter Code. Dieser Artikel erklärt, was Clean Code meint, woher der Begriff kommt und welche Werte dahinterstehen, wie Du Kopplung und Kohäsion beurteilst und Code Smells erkennst. Eine Landkarte ordnet die Prinzipien der Artikelreihe den Ebenen Ausdruck, Methode, Klasse, Klassenbeziehung und Entwurf zu; dazu kommen die Praktiken, die Kritik an Clean Code und die Frage, wie Du KI-generierten Code prüfst.

Leitfragen und Übungsaufgaben zum roten Grad des Clean-Code-Developers

Leitfragen und Übungsaufgaben zu Clean Code: Der Artikel enthält eine Reihe von Leitfragen zum Verständnis der Prinzipien (DRY, KISS, BoPO, FCoI, IOSP) und Praktiken (Boy Scout, Root Cause, VCS, Refactoring, Reflection), die im roten Grad des Clean-Code-Developers zusammengefasst sind. Am Ende findet sich eine praktische Übungsaufgabe, bei der Clean-Code-Prinzipien angewendet werden sollen.