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:
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.
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:
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.
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.
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.
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.
}
}
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.
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:
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.
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.
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.
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.
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:
— 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!
Lösung zum Neustarten und Auswählen des richtigen Startgeräts
So öffnen Sie eine URL-Datei
PS Farbeimer-Tastenkombinationen
Was ist mit dem roten Licht am Lichtsignal los?
So lösen Sie das Problem, dass die Datei msxml6.dll fehlt
Metasuchmaschine
So wechseln Sie zwischen voller und halber Breite
Verwendung des js-Shift-Operators
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
