SOLID in modernen Programmiersprachen

Das SOLID-Prinzip ist eine Sammlung von fünf grundlegenden Designprinzipien, die ursprünglich von Robert C. Martin entwickelt wurden. Diese Prinzipien bieten eine solide Grundlage für das Erstellen von wartbarem, erweiterbarem und robustem Code. In modernen Programmiersprachen wie C++ kommen diese Prinzipien ebenfalls zur Anwendung und tragen zur Optimierung der Softwarearchitektur bei.

1. Single Responsibility Principle (SRP)

Das Single Responsibility Principle besagt, dass eine Klasse nur eine einzige Verantwortlichkeit haben sollte. In C++ bedeutet dies, dass eine Klasse nur für eine Aufgabe zuständig ist. Wenn eine Klasse zu viele Aufgaben übernimmt, wird der Code schwieriger zu verstehen und zu warten.

Vorteil:
Durch das SRP wird der Code klar strukturiert, und jede Klasse hat eine eindeutige Funktion. Dies führt zu besserem Testen und geringeren Fehlern.

Nachteil:
Das Prinzip kann zu vielen kleinen Klassen führen, was die Übersichtlichkeit erschwert, besonders bei sehr komplexen Anwendungen.

Beispiel SRP in C++:

class FileManager {
public:
    void readFromFile(const std::string& filename);
    void writeToFile(const std::string& filename);
};

class Logger {
public:
    void logMessage(const std::string& message);
};

Die Trennung von Dateiverwaltung und Logging entspricht dem SRP.

Beispiel SRP in Python:

Beispiel ohne SRP:

In diesem Beispiel hat die Employee-Klasse sowohl die Verantwortung für das Speichern von Mitarbeiterinformationen als auch für das Drucken von Berichten.

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def calculate_salary(self):
        return self.salary

    def print_report(self):
        print(f"Employee: {self.name}, Salary: {self.salary}")

Diese Klasse hat zwei Verantwortlichkeiten:

1. Berechnung des Gehalts.
2. Drucken des Berichts.

Beispiel mit SRP:

Wir trennen die Verantwortlichkeiten, indem wir eine Klasse für die Gehaltsberechnung und eine für das Drucken des Berichts erstellen.

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def calculate_salary(self):
        return self.salary


class ReportPrinter:
    def print_report(self, employee):
        print(f"Employee: {employee.name}, Salary: {employee.salary}")

Verwendung:

Nun haben wir die Verantwortlichkeiten getrennt. Employee ist nur für die Speicherung der Mitarbeiterinformationen und die Berechnung des Gehalts verantwortlich. Die Klasse ReportPrinter ist für das Drucken des Berichts zuständig.

employee = Employee("John Doe", 5000)
printer = ReportPrinter()

printer.print_report(employee)

In diesem verbesserten Beispiel hat jede Klasse nur eine Verantwortung, was das Prinzip von SRP widerspiegelt.

2. Open/Closed Principle (OCP)

Das Open/Closed Principle besagt, dass Klassen für Erweiterungen offen, aber für Veränderungen geschlossen sein sollten. In C++ wird dies oft durch die Verwendung von abstrakten Basisklassen oder Schnittstellen umgesetzt.

Vorteil:
Neue Funktionalitäten können hinzugefügt werden, ohne bestehende Klassen zu ändern, was die Software stabiler macht.

Nachteil:
Die Umsetzung kann die Komplexität erhöhen, da mehr abstrakte Klassen und Schnittstellen notwendig sind.

Beispiel in C++:

class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    double area() const override {
        return 3.14 * radius * radius;
    }
private:
    double radius;
};

class Square : public Shape {
public:
    double area() const override {
        return side * side;
    }
private:
    double side;
};

Durch die Einführung von Shape können neue geometrische Formen leicht hinzugefügt werden, ohne die bestehenden Klassen zu verändern.

Beispiel OCP in Python:

Beispiel ohne OCP:

Angenommen, wir haben eine Klasse AreaCalculator, die die Fläche von verschiedenen Formen berechnet. Wenn wir neue Formen hinzufügen möchten, müssen wir den bestehenden Code ändern.

class AreaCalculator:
    def calculate_area(self, shape):
        if isinstance(shape, Rectangle):
            return shape.width * shape.height
        elif isinstance(shape, Circle):
            return 3.14 * shape.radius * shape.radius
        else:
            raise ValueError("Unbekannte Form")
        
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

class Circle:
    def __init__(self, radius):
        self.radius = radius

Wenn wir eine neue Form, z.B. Triangle, hinzufügen möchten, müssen wir die AreaCalculator-Klasse ändern:

class Triangle:
    def __init__(self, base, height):
        self.base = base
        self.height = height

# Jetzt müssen wir die `AreaCalculator`-Klasse ändern, um das Dreieck zu unterstützen.

Beispiel mit OCP:

Um das OCP zu respektieren, können wir die Berechnung von Flächen in eine Basis-Klasse oder ein Interface extrahieren und dann jede Form als separate Klasse erweitern, ohne den Code in AreaCalculator zu ändern.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def calculate_area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.14 * self.radius * self.radius

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def calculate_area(self):
        return 0.5 * self.base * self.height

class AreaCalculator:
    def calculate_area(self, shape: Shape):
        return shape.calculate_area()

Verwendung:

Jetzt können wir neue Formen hinzufügen, indem wir nur neue Klassen für jede Form erstellen, ohne den bestehenden Code der AreaCalculator-Klasse zu ändern:

rectangle = Rectangle(4, 5)
circle = Circle(3)
triangle = Triangle(6, 8)

calculator = AreaCalculator()

print(f"Rechteck Fläche: {calculator.calculate_area(rectangle)}")
print(f"Kreis Fläche: {calculator.calculate_area(circle)}")
print(f"Dreieck Fläche: {calculator.calculate_area(triangle)}")

• In diesem Beispiel ist die AreaCalculator-Klasse geschlossen für Änderungen (wir müssen den Code dort nicht anpassen), aber offen für Erweiterungen (wir können neue Formen wie Triangle hinzufügen, indem wir die Shape-Klasse erweitern).
• Dies entspricht dem Open/Closed Principle (OCP), das eine Erweiterbarkeit des Systems ermöglicht, ohne den bestehenden Code zu verändern.

3. Liskov Substitution Principle (LSP)

Das Liskov Substitution Principle verlangt, dass Objekte einer abgeleiteten Klasse ohne Probleme durch Objekte der Basisklasse ersetzt werden können. In C++ bedeutet das, dass abgeleitete Klassen die Verträge der Basisklassen nicht verletzen sollten.

Vorteil:
LSP stellt sicher, dass das Verhalten von abgeleiteten Klassen mit der Basisklasse kompatibel bleibt. Dies verhindert unerwartetes Verhalten.

Nachteil:
Manchmal kann die Einhaltung des LSP die Flexibilität von Klassen einschränken, insbesondere wenn spezielle Anpassungen erforderlich sind.

Beispiel in C++:

class Bird {
public:
    virtual void fly() = 0;
};

class Sparrow : public Bird {
public:
    void fly() override {
        // Fliegt
    }
};

class Ostrich : public Bird {
public:
    void fly() override {
        // Fliegen nicht möglich, führt zu Fehlern
    }
};

Das Ostrich-Beispiel verstößt gegen LSP, da nicht alle Vögel fliegen können.

4. Interface Segregation Principle (ISP)

Das Interface Segregation Principle empfiehlt, dass Schnittstellen klein und spezifisch bleiben sollten. Große, allumfassende Schnittstellen führen zu unübersichtlichem Code. Statt einer großen Schnittstelle sollten mehrere kleinere und fokussierte Schnittstellen erstellt werden.

Vorteil:
Durch kleinere Schnittstellen wird der Code leichter zu verstehen und zu testen.

Nachteil:
Die Einführung vieler kleiner Schnittstellen kann zu einer höheren Komplexität in der Verwaltung und Organisation des Codes führen.

Beispiel in C++:

class Flyable {
public:
    virtual void fly() = 0;
};

class Swimmable {
public:
    virtual void swim() = 0;
};

class Duck : public Flyable, public Swimmable {
public:
    void fly() override {
        // Fliegt
    }

    void swim() override {
        // Schwimmt
    }
};

Durch das Aufteilen der Funktionen in Flyable und Swimmable erhält jede Klasse nur die Methoden, die sie benötigt.

5. Dependency Inversion Principle (DIP)

Das Dependency Inversion Principle besagt, dass High-Level-Module nicht von Low-Level-Modulen abhängen sollten. Beide sollten von Abstraktionen abhängen. In C++ bedeutet dies, dass konkrete Implementierungen nicht direkt in den Klassen verwendet werden, sondern Abstraktionen.

Vorteil:
Die Entkopplung von Komponenten führt zu einer besseren Wartbarkeit und Flexibilität. Code lässt sich leichter testen und erweitern.

Nachteil:
Die Implementierung von DIP erfordert eine sorgfältige Planung und möglicherweise zusätzliche Abstraktionen, was die Komplexität erhöht.

Beispiel in C++:

class Database {
public:
    virtual void saveData(const std::string& data) = 0;
};

class MySQLDatabase : public Database {
public:
    void saveData(const std::string& data) override {
        // Speichert in MySQL
    }
};

class Application {
public:
    Application(Database* db) : db_(db) {}

    void save(const std::string& data) {
        db_->saveData(data);
    }

private:
    Database* db_;
};

Die Abhängigkeit von Database anstelle einer konkreten Implementierung sorgt für Flexibilität bei der Auswahl der Datenbank.

Fazit

Die Anwendung der SOLID-Prinzipien in modernen Programmiersprachen wie C++ und Python führt zu klar strukturiertem, wartbarem und erweiterbarem Code. Die Vorteile liegen in der besseren Trennung von Verantwortlichkeiten und der Flexibilität, bestehende Systeme ohne große Änderungen zu erweitern.

Vorteile:

• Klare und wartbare Codebasis
• Einfachere Erweiterbarkeit und Testbarkeit
• Bessere Fehlersuche und -vermeidung

Nachteile:

• Potenziell komplexere Architektur
• Höherer Aufwand bei der Implementierung von Abstraktionen
• Kann zu einer größeren Anzahl von Klassen führen

Fazit

Trotz der Nachteile ist die Anwendung von SOLID-Prinzipien in modernen Programmiersprachen wie C++ eine bewährte Methode zur Verbesserung der Codequalität und der Softwarearchitektur. In diesem Artikel SOLID in modernen Programmiersprachen haben wir zu den einzelnen Regeln die Vor- und Nachteile aufgezeigt und mit einfachen Beispielen in die Praxis umgesetzt.

Auch interessant: SOLID Design Prinzipien​ und Testbarkeit und SOLID