SOLID ist eine Sammlung grundlegender Prinzipien, die darauf abzielen, die Verwaltbarkeit und Skalierbarkeit von Code in der objektorientierten Programmierung (OOP) zu verbessern. Es besteht aus fünf Grundprinzipien:

1. S Einzelverantwortungsprinzip? – ?SRP
2. O Stift-geschlossenes Prinzip? – ?OCP
3. L iskovs Substitutionsprinzip? – ?LSP
4. I Prinzip der Schnittstellentrennung? – ?ISP
5. D Abh?ngigkeitsinversionsprinzip? – ?DIP

Diese Prinzipien wurden Anfang der 2000er Jahre von Robert C. Martin (auch bekannt als Uncle Bob) eingeführt und haben seitdem in der Softwareentwicklungsgemeinschaft breite Anwendung gefunden. Durch die Befolgung der SOLID-Prinzipien k?nnen Entwickler Code erstellen, der leichter zu verstehen, zu ?ndern und zu erweitern ist, was zu robusteren und wartbareren Softwaresystemen führt.

Prinzip der Einzelverantwortung (SRP)

Das Prinzip der Einzelverantwortung ist das erste und grundlegendste Prinzip in OOP und SOLID. Wie der Name schon sagt, bedeutet dieses Prinzip ?Eine Klasse sollte nur eine bestimmte Verantwortung haben, um die sie sich kümmern muss“.

Angenommen, wir haben eine Klasse namens Invoice, die zwei Methoden genericInvoice() und saveToFiles() enth?lt.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Dies ist keine gute Vorgehensweise, da die Rechnungsklasse zwei Verantwortlichkeiten hat. Ein besserer Ansatz w?re, diese Funktionalit?ten in dedizierte Klassen zu unterteilen.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Hier k?nnen wir sehen, dass wir zwei Klassen für den Anwendungsfall haben:

• Rechnung erstellen
• Speichern Sie es in Dateien

Vorteile der Einhaltung von SRP

• Verbesserte Code-Organisation: Durch die Aufteilung von Bedenken in verschiedene Klassen wird die Codebasis besser organisiert und einfacher zu navigieren.
• Bessere Wartbarkeit: Wenn eine Klasse eine einzige Verantwortung hat, ist es einfacher, ihren Zweck zu verstehen und ?nderungen ohne unbeabsichtigte Nebenwirkungen vorzunehmen.
• Erh?hte Wiederverwendbarkeit: Klassen mit einer einzigen Verantwortung sind eher in verschiedenen Teilen der Anwendung oder sogar in anderen Projekten wiederverwendbar.
• Einfacheres Testen: Klassen mit einer einzigen Verantwortung sind in der Regel kleiner und fokussierter, sodass sie einfacher isoliert getestet werden k?nnen.

Open-Closed-Prinzip (OCP)

Das Open-Closed-Prinzip ist ein weiteres Kernprinzip von SOLID. Dieses Prinzip wurde 1997 von Bertrand Meyer eingeführt. Die Idee hinter diesem Prinzip lautet: ?Softwareartefakte (Klassen, Module und Funktionen) sollten für Erweiterungen ge?ffnet, für ?nderungen jedoch geschlossen sein.“

Zum Beispiel;

Nehmen wir an, wir haben eine Klasse namens Shape. Mit dieser Klasse k?nnen wir die Fl?che der Form berechnen.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Im obigen Code erfordert das Hinzufügen einer neuen Form eine ?nderung der vorhandenen Shape-Klasse, was nicht als bew?hrte Vorgehensweise gilt.

Unten finden Sie ein Codebeispiel, das zeigt, wie das Open-Closed-Prinzip auf dieses Szenario angewendet wird.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Mit der Anwendung von OCP k?nnen wir beliebig viele Formen hinzufügen, ohne die aktuelle Implementierung zu ?ndern.

HINWEIS: Die Verwendung von Schnittstellen ist nicht die einzige M?glichkeit, OCP zu erreichen.

Vorteile der Befolgung von OCP

• Reduziertes Fehlerrisiko: Indem vorhandener Code nicht ge?ndert wird, wird das Risiko der Einführung neuer Fehler oder der Beeintr?chtigung vorhandener Funktionen minimiert.
• Verbesserte Wartbarkeit: Code, der dem OCP folgt, ist einfacher zu warten und zu erweitern, da neue Funktionen hinzugefügt werden k?nnen, ohne die vorhandene Codebasis zu ?ndern.
• Erh?hte Flexibilit?t: Die Verwendung von Abstraktionen und Polymorphismus erm?glicht flexiblere und anpassungsf?higere Designs und erleichtert so die Anpassung an sich ?ndernde Anforderungen.

Liskovs Substitutionsprinzip (LSP)

Liskovs Substitutionsprinzip ist ein weiteres wichtiges Prinzip in OOP. Es wurde 1987 von Barbara Liskov w?hrend eines Konferenzvortrags über Datenabstraktion vorgestellt.

Das Prinzip besagt: ?Objekte einer Oberklasse sollten durch Objekte ihrer Unterklassen ersetzbar sein, ohne die Korrektheit des Programms zu ver?ndern.“

Wenn beispielsweise Kreis und Rechteck Untertypen von Form sind, sollten wir in der Lage sein, das Formobjekt ohne Probleme durch ein Kreis- oder Rechteckobjekt zu ersetzen.

public class Shape {
    private String shapeType;
    private double radius;
    private double length;
    private double width;

    public Shape(String shapeType, double radius, double length, double width) {
        this.shapeType = shapeType;
        this.radius = radius;
        this.length = length;
        this.width = width;
    }

    public double area() {
        if (shapeType.equals("circle")) {
            return Math.PI * (radius * radius);
        } else if (shapeType.equals("rectangle")) {
            return length * width;
        } else {
            throw new IllegalArgumentException("Unknown shape type");
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle = new Shape("circle", 5, 0, 0);
        Shape rectangle = new Shape("rectangle", 0, 4, 6);

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

Wie in diesem Beispiel gezeigt, bedeutet die Einhaltung des Liskov-Substitutionsprinzips, dass wir in der Lage sein sollten, eine Superklasseninstanz nahtlos durch eine Unterklasseninstanz zu ersetzen.

Vorteile der Befolgung von LSP

• Verbesserte Code-Wiederverwendbarkeit: Indem sichergestellt wird, dass Subtypen ihre Basistypen ersetzen k?nnen, kann Code, der den Basistyp verwendet, auch mit jedem seiner Subtypen funktionieren, was die Wiederverwendung von Code f?rdert.
• Verbesserte Wartbarkeit: Code, der LSP folgt, ist einfacher zu warten, da er das Risiko der Einführung von Fehlern beim ?ndern oder Erweitern der Codebasis verringert.
• Bessere Testbarkeit: LSP erleichtert das Schreiben von Komponententests für Klassen und ihre Untertypen, da die Tests gegen den Basistyp geschrieben werden k?nnen und für alle Untertypen funktionieren sollten.

Prinzip der Schnittstellentrennung (ISP)

Das Interface-Segregationsprinzip ist eines der fünf SOLID-Prinzipien, die von Robert C. Martin eingeführt wurden. Darin hei?t es: ?Clients sollten nicht gezwungen werden, sich auf Schnittstellen zu verlassen, die sie nicht nutzen.“

Mit anderen Worten: Die Verwendung vieler aufgabenspezifischer Schnittstellen ist besser als die Verwendung einer Allzweckschnittstelle.

Das folgende Beispiel zeigt die Verwendung einer Allzweckschnittstelle.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Die Verwendung einer Allzweckschnittstelle wie Multifunktionsdrucker zwingt uns dazu, unn?tige Methoden zu implementieren, was als schlechte Praxis angesehen wird. Lassen Sie uns untersuchen, wie wir das Prinzip der Schnittstellentrennung auf dieses Szenario anwenden k?nnen.

Schnittstellen

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Implementierungen

public class Shape {
    private String shapeType;
    private double radius;
    private double length;
    private double width;

    public Shape(String shapeType, double radius, double length, double width) {
        this.shapeType = shapeType;
        this.radius = radius;
        this.length = length;
        this.width = width;
    }

    public double area() {
        if (shapeType.equals("circle")) {
            return Math.PI * (radius * radius);
        } else if (shapeType.equals("rectangle")) {
            return length * width;
        } else {
            throw new IllegalArgumentException("Unknown shape type");
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle = new Shape("circle", 5, 0, 0);
        Shape rectangle = new Shape("rectangle", 0, 4, 6);

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

Durch die Anwendung des ISP teilen wir ihn in kleinere, rollenspezifische Schnittstellen auf – wie Drucker, Scanner und Fax. Dadurch kann jede Klasse (z. B. BasicPrinter, AdvancedPrinter oder FaxMachine) nur die relevante Funktionalit?t implementieren, wodurch die Modularit?t gef?rdert und unn?tige Abh?ngigkeiten reduziert werden.

Vorteile, wenn Sie einem ISP folgen

• Modularer und wiederverwendbarer Code: Durch die Aufteilung gro?er Schnittstellen in kleinere, spezifischere Schnittstellen wird der Code modularer und wiederverwendbarer. Klassen oder Module k?nnen nur die Schnittstellen implementieren, die sie ben?tigen, wodurch unn?tige Abh?ngigkeiten reduziert werden und die Wiederverwendung von Code in verschiedenen Teilen des Systems einfacher wird.
• Reduzierte Codekomplexit?t: Wenn Klassen oder Module nur von den Schnittstellen abh?ngen, die sie ben?tigen, wird der Code weniger komplex und leichter zu verstehen. Dies liegt daran, dass sich Entwickler nicht mit unn?tigen Methoden oder Abh?ngigkeiten auseinandersetzen müssen. Diese sind für ihren spezifischen Anwendungsfall nicht relevant.
• Verbesserte Wartbarkeit: Mit kleineren und fokussierteren Schnittstellen wird es einfacher, den Code zu warten. ?nderungen an einer Schnittstelle wirken sich weniger wahrscheinlich auf andere Teile des Systems aus, wodurch das Risiko der Einführung von Fehlern oder der Beeintr?chtigung vorhandener Funktionen verringert wird.
• Bessere Testbarkeit: Kleinere und fokussiertere Schnittstellen erleichtern das Schreiben von Komponententests für einzelne Komponenten. Dies liegt daran, dass sich die Tests auf bestimmte Verhaltensweisen konzentrieren k?nnen, ohne durch irrelevante Methoden oder Abh?ngigkeiten beeintr?chtigt zu werden.
• Erh?hte Flexibilit?t: Durch die Bindung an den ISP wird das System flexibler und l?sst sich einfacher erweitern oder ?ndern. Neue Funktionen oder Anforderungen k?nnen hinzugefügt werden, indem neue Schnittstellen erstellt oder bestehende ge?ndert werden, ohne dass sich dies auf das gesamte System auswirkt.

Abh?ngigkeitsinversionsprinzip (DIP)

Das Abh?ngigkeitsinversionsprinzip ist das letzte Prinzip von SOLID. Was auch von Robert C. Martin eingeführt wurde. Dies f?rdert lose gekoppelten Code.

DIP gibt einige Punkte an:

• High-Level-Module sollten nicht von Low-Level-Modulen abh?ngen.
• Beide sollten von der Abstraktion abh?ngen.
• Abstraktion sollte nicht von Details abh?ngen.
• Details sollten von der Abstraktion abh?ngen.

Einfach ausgedrückt sollte eine Klasse nicht direkt von anderen spezifischen Klassen (konkreten Implementierungen) abh?ngig sein, sondern von Schnittstellen oder abstrakten Klassen. Dadurch wird der Code flexibler und einfacher zu warten, da Sie Implementierungen austauschen k?nnen, ohne die abh?ngige Klasse zu ?ndern.

Eng gekoppelter Code (ohne DIP)

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

Wie im obigen Beispiel gezeigt, h?ngt die Computerklasse direkt von der Tastaturklasse ab.

Lose gekoppelter Code (mit DIP)

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Jetzt ist der Computer auf die InputDevice-Schnittstelle angewiesen, nicht auf eine bestimmte Tastatur. Dies erleichtert den Wechsel zu einem anderen Eingabeger?t, beispielsweise einer drahtlosen Tastatur, ohne die Computerklasse zu ?ndern.

Vorteile der Befolgung von DIP

• Lose Kopplung: Durch die Abh?ngigkeit von Abstraktionen statt von konkreten Implementierungen wird der Code weniger eng gekoppelt, wodurch es einfacher wird, einen Teil des Systems zu ?ndern, ohne andere zu beeinflussen.
• Verbesserte Wartbarkeit: ?nderungen an Low-Level-Modulen wirken sich nicht auf High-Level-Module aus, wodurch das System einfacher zu warten und zu erweitern ist.
• Verbesserte Testbarkeit: High-Level-Module k?nnen mithilfe von Scheinimplementierungen der Low-Level-Module getestet werden, wodurch das Testen schneller und zuverl?ssiger wird.
• Erh?hte Wiederverwendbarkeit: High-Level-Module k?nnen in verschiedenen Kontexten wiederverwendet werden, ohne dass die Low-Level-Module, von denen sie abh?ngen, ge?ndert werden müssen.

Abschluss

Zusammenfassend l?sst sich sagen, dass die SOLID-Prinzipien: Single Responsibility, Open-Closed, Liskov-Substitution, Interface Segregation und Dependency Inversion wesentliche Richtlinien für das Schreiben von sauberem, wartbarem und skalierbarem Code in der objektorientierten Programmierung bieten.

Durch die Einhaltung dieser Prinzipien k?nnen Entwickler Systeme erstellen, die einfacher zu verstehen, zu ?ndern und zu erweitern sind, was letztendlich zu qualitativ hochwertigerer Software und effizienteren Entwicklungsprozessen führt.

Zusammenfassung

Vielen Dank für das Lesen dieses Artikels! Ich hoffe, Sie haben jetzt ein solides Verst?ndnis der SOLID-Prinzipien und wie Sie sie anwenden k?nnen, um Ihre Projekte zu verbessern.

Folgen Sie mir auf:

LinkedIn?—?@nsadisha
GitHub?—?@nsadisha
Mittel?—?@nsadisha
Dev.to?—?@nsadisha

— Sadisha Nimsara

Das obige ist der detaillierte Inhalt vonSOLIDE Prinzipien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!