Open Closed Prinzip

Das Open Closed Prinzip ist eines der SOLID-Prinzipien, die von Robert C. Martin formuliert wurden. Es besagt, dass Softwaremodule (wie Klassen, Module oder Funktionen) offen für Erweiterungen, aber geschlossen für Modifikationen sein sollten. Das bedeutet, dass bestehender Code nicht verändert werden muss, um neue Funktionalitäten hinzuzufügen. Stattdessen sollte er durch Erweiterungen erweitert werden, ohne bestehende Implementierungen zu beeinflussen. Dieses Prinzip fördert die Wartbarkeit, Erweiterbarkeit und Flexibilität von Software.

In diesem Artikel werden wir das Open/Closed Prinzip detailliert untersuchen, Beispiele in C++ verwenden und sowohl die Vorteile als auch die möglichen Nachteile dieses Prinzips betrachten.

Was ist das Open/Closed Prinzip?

Das Open/Closed Prinzip besagt, dass Softwarekomponenten (Klassen, Funktionen, Module) auf eine Weise entworfen werden sollten, die es ermöglicht, neue Funktionalitäten hinzuzufügen, ohne den bestehenden Code zu verändern. Das bedeutet nicht, dass der Code vollständig unveränderlich ist. Stattdessen sollen Erweiterungen in einer Weise vorgenommen werden, die den ursprünglichen Code intakt lässt.

Das OCP hilft dabei, die Stabilität und Wartbarkeit eines Systems zu verbessern. Wenn der Code modifiziert wird, um neue Anforderungen zu erfüllen, besteht immer das Risiko, bestehende Funktionalitäten zu beeinträchtigen. Mit dem OCP können neue Anforderungen durch Hinzufügen neuer Klassen oder Module ohne Veränderung des bestehenden Codes erfüllt werden.

Prinzip in der Praxis: Beispiel in C++

Betrachten wir ein einfaches Beispiel, das das Open Closed Prinzip verdeutlicht. Wir beginnen mit einer nicht optimalen Implementierung und verbessern sie nach und nach, um das Prinzip umzusetzen.

Beispiel ohne Open Closed Prinzip

#include <iostream>
#include <vector>

// Funktion zum Berechnen der Fläche von verschiedenen Formen
class Shape {
public:
    virtual double getArea() = 0;
};

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double getArea() override {
        return width * height;
    }
};

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

class AreaCalculator {
public:
    double calculateArea(std::vector<Shape*>& shapes) {
        double totalArea = 0;
        for (auto shape : shapes) {
            totalArea += shape->getArea(); // Berechnung der Fläche für jedes Shape
        }
        return totalArea;
    }
};

In diesem Beispiel haben wir eine Shape-Klasse, die als Basis für verschiedene Formen wie Rechteck und Kreis dient. Die AreaCalculator-Klasse berechnet die Fläche aller übergebenen Formen.

Angenommen, es gibt eine neue Form wie ein Dreieck, und wir müssen die AreaCalculator-Klasse anpassen, um auch die Fläche von Dreiecken zu berechnen. In dieser Implementierung müssten wir die AreaCalculator-Klasse ändern, um eine spezielle Berechnung für Dreiecke hinzuzufügen. Diese Änderung verletzt das Open/Closed Prinzip, da die AreaCalculator-Klasse modifiziert werden muss, um neue Funktionalitäten hinzuzufügen.

Verbesserung nach dem Open/Closed Prinzip

Um das Open Closed Prinzip zu respektieren, erweitern wir das System, ohne die bestehenden Klassen zu ändern. Wir schaffen eine erweiterbare Struktur, bei der neue Formen problemlos hinzugefügt werden können, ohne die bestehende Funktionalität zu verändern.

#include <iostream>
#include <vector>

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

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double getArea() override {
        return width * height;
    }
};

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

class Triangle : public Shape {
private:
    double base, height;
public:
    Triangle(double b, double h) : base(b), height(h) {}
    double getArea() override {
        return 0.5 * base * height;
    }
};

class AreaCalculator {
public:
    double calculateArea(std::vector<Shape*>& shapes) {
        double totalArea = 0;
        for (auto shape : shapes) {
            totalArea += shape->getArea();
        }
        return totalArea;
    }
};

In dieser verbesserten Version haben wir eine neue Form Triangle hinzugefügt, die die Shape-Klasse erweitert. Die AreaCalculator-Klasse bleibt unverändert und berechnet weiterhin die Fläche jeder Form, die das Shape-Interface implementiert. Dies entspricht dem Open/Closed Prinzip, da wir eine neue Funktionalität (die Berechnung der Fläche von Dreiecken) hinzugefügt haben, ohne bestehende Klassen oder Funktionen zu ändern.

Vorteile des Open Closed Prinzips

Erweiterbarkeit: Neue Funktionalitäten können problemlos hinzugefügt werden, ohne den bestehenden Code zu ändern. Dies fördert die Anpassungsfähigkeit des Systems bei neuen Anforderungen.
Wartbarkeit: Da der bestehende Code nicht verändert werden muss, bleibt er stabil. Änderungen werden nur in Erweiterungen vorgenommen, was die Wartung vereinfacht.
Reduzierte Fehleranfälligkeit: Durch die Minimierung der Anzahl der Codeänderungen sinkt das Risiko, bestehende Funktionalitäten zu beeinträchtigen.
Bessere Code-Struktur: Die Trennung von Erweiterungen und Modifikationen führt zu einer klareren Struktur und einer besseren Organisation des Codes.
Fördert gutes Design: Das Prinzip fördert die Verwendung von Abstraktionen, Interfaces und Vererbung, was zu einem sauberen und skalierbaren Design führt.

Nachteile des Open Closed Prinzips

Komplexität der Implementierung: Das Design eines Systems, das dem Open/Closed Prinzip entspricht, kann komplexer sein. Entwickler müssen sicherstellen, dass die Erweiterungen nahtlos in das bestehende System integriert werden.
Übermäßige Verwendung von Vererbung: Das OCP fördert oft die Verwendung von Vererbung, was in manchen Fällen zu einer zu tiefen Vererbungshierarchie führen kann. Dies kann den Code schwer nachvollziehbar und wartbar machen.
Erhöhter Initialaufwand: Beim Entwurf des Systems müssen Entwickler möglicherweise mehr Aufwand in die Planung und Strukturierung investieren, um sicherzustellen, dass es leicht erweiterbar ist.
Überanpassung des Designs: Das Streben nach Erweiterbarkeit kann manchmal zu einer Überanpassung des Designs führen, bei der unnötig viele Erweiterungspunkte geschaffen werden. Dies kann die Codebasis unnötig verkomplizieren.
Potentielle Leistungseinbußen: Wenn viele Erweiterungen und Abstraktionen eingeführt werden, kann dies die Leistung beeinträchtigen. Die zusätzliche Abstraktionsebene kann zu einer höheren Komplexität und zu Performance-Problemen führen.

Wie wird das Open-Closed-Prinzip im Code verletzt?

Das Open-Closed-Prinzip (OCP) ist eines der SOLID-Prinzipien der objektorientierten Softwareentwicklung. Es besagt, dass Softwaremodule (z. B. Klassen, Methoden) offen für Erweiterungen, aber geschlossen für Änderungen sein sollten. Das bedeutet, dass du die Funktionalität einer bestehenden Klasse erweitern kannst, ohne ihren Code zu verändern.

Das Open-Closed-Prinzip wird verletzt, wenn du Änderungen am bestehenden Code vornehmen musst, um neue Funktionen hinzuzufügen, statt neue Klassen oder Erweiterungen zu implementieren. Hier sind einige Beispiele, wie dieses Prinzip verletzt werden kann:

1. Direkte Modifikation des bestehenden Codes

Wenn du eine Klasse oder Methode ändern musst, um neue Anforderungen zu erfüllen, statt eine neue Klasse hinzuzufügen oder bestehende Klassen zu erweitern, verletzt das das OCP.

Beispiel – Verletzung des OCP:

class Berechnungsmodul:
    def berechne_preis(self, typ):
        if typ == "standard":
            return 100.0
        elif typ == "special":
            return 150.0
        # Wenn ein neuer Typ hinzukommt, muss die Methode geändert werden.

Problem: Wenn ein neuer Typ hinzukommt (z. B. "exklusiv"), musst du den Code der Methode berechne_preis() ändern.

Besser – OCP einhalten:

from abc import ABC, abstractmethod

class PreisBerechner(ABC):
    @abstractmethod
    def berechne_preis(self):
        pass

class StandardPreisBerechner(PreisBerechner):
    def berechne_preis(self):
        return 100.0

class SpecialPreisBerechner(PreisBerechner):
    def berechne_preis(self):
        return 150.0

# Neue Preisberechner-Klassen können hinzugefügt werden, ohne den bestehenden Code zu ändern.

2. Verwendung von `if` oder `match`-Anweisungen zur Entscheidung zwischen verschiedenen Verhaltensweisen

Die Entscheidung über das Verhalten innerhalb einer Methode, basierend auf einem spezifischen Parameter (z. B. if oder match), kann dazu führen, dass der Code schwer erweiterbar wird, wenn neue Typen oder Verhaltensweisen hinzugefügt werden müssen.

Beispiel – Verletzung des OCP:

class Geometrie:
    def berechne_flaeche(self, form):
        if isinstance(form, Kreis):
            return 3.14 * form.radius ** 2
        elif isinstance(form, Rechteck):
            return form.breite * form.hoehe
        # Wenn neue Formen hinzugefügt werden, müssen neue if-else Bedingungen eingefügt werden.

Problem: Wenn eine neue Form (z. B. Dreieck) hinzukommt, muss der Code geändert werden.

Besser – OCP einhalten:

from abc import ABC, abstractmethod

class Form(ABC):
    @abstractmethod
    def berechne_flaeche(self):
        pass

class Kreis(Form):
    def __init__(self, radius):
        self.radius = radius

    def berechne_flaeche(self):
        return 3.14 * self.radius ** 2

class Rechteck(Form):
    def __init__(self, breite, hoehe):
        self.breite = breite
        self.hoehe = hoehe

    def berechne_flaeche(self):
        return self.breite * self.hoehe

# Neue Formen können durch Erweiterung der Form-Klasse hinzugefügt werden, ohne den bestehenden Code zu verändern.

Zusammenfassung

Das Open-Closed-Prinzip wird verletzt, wenn du:

Bestehenden Code ändern musst, um neue Funktionalitäten zu integrieren.
Eine Klasse oder Methode mit if/switch-Anweisungen erweiterst, anstatt die Erweiterbarkeit durch Vererbung und Polymorphismus sicherzustellen.

Um das Open-Closed-Prinzip zu wahren, sollten Änderungen an der Funktionsweise durch Erweiterungen (z. B. durch Vererbung, Schnittstellen oder Dekoratoren) und nicht durch direkte Änderungen am bestehenden Code erreicht werden.

Fazit

Das Open Closed Prinzip ist ein grundlegendes Konzept in der objektorientierten Softwareentwicklung. Es fördert die Erweiterbarkeit und Wartbarkeit von Software, indem es sicherstellt, dass bestehende Module nicht verändert werden müssen, um neue Funktionalitäten hinzuzufügen. Durch die Einhaltung dieses Prinzips können Entwickler stabile und leicht erweiterbare Systeme bauen, die gut auf neue Anforderungen reagieren können.

Trotz der vielen Vorteile gibt es auch Herausforderungen, insbesondere bei der Komplexität des Designs und der Notwendigkeit, das richtige Maß an Erweiterbarkeit zu finden. Dennoch bietet das Open/Closed Prinzip einen klaren Vorteil, indem es den Code robuster und zukunftssicher macht.

Insgesamt ist das Open/Closed Prinzip ein wertvolles Werkzeug, um Software so zu gestalten, dass sie flexibel bleibt und Änderungen ohne Risiko von Fehlern vorgenommen werden können.

Weiter zu einem Beitrag mit mehr Hardware-Nähe: Neues vom STM32