Wenn Sie darüber nachdenken, Ihre eigene Software zu entwickeln, ist es an der Zeit, einen Blick auf die soliden Prinzipien zu werfen. Das sind Begriffe, die sich in der Softwareentwicklung durchgesetzt haben und die Sie sehr gut beherrschen müssen, um ein wettbewerbsfähiges Projekt zu erstellen. 

Es handelt sich um ein Regelwerk, das Sie durch den gesamten Prozess der objektorientierten Programmierung führt, damit Sie ein Programm erstellen können, das den Bedürfnissen des Benutzers entspricht.

Vergessen Sie Improvisation und Änderungen in letzter Minute. Mit diesen Grundsätzen haben Sie den Leitfaden, den Sie so sehr gebraucht haben. 

Sollen wir jetzt anfangen?

Was ist ein solides Prinzip?

Lassen Sie uns zunächst definieren, was solide Prinzipien sind. Sie sind eine Reihe von Regeln und Praktiken, die bei der objektorientierten Programmierung befolgt werden müssen, um eine Klassenstruktur von Grund auf zu erstellen. 

Jedes dieser Prinzipien hilft uns, die Anforderungen einiger Entwurfsmuster und der Softwarearchitektur im Allgemeinen zu verstehen, so dass alle Entwickler dieses Thema perfekt beherrschen müssen, um ihre Ziele zu erreichen. 

Die Idee dieser Prinzipien ist es, sie flexibler, verständlicher und skalierbarer zu machen, um allen zukünftigen Veränderungen standzuhalten. Auf diese Weise zeigen die Prinzipien, wie wir Funktionen und Datenstrukturen in Komponenten organisieren sollten und wie sie miteinander verbunden werden sollten. 

Lesen Sie weiter und erfahren Sie mehr 

Hintergrund

Die Solid-Prinzipien wurden erstmals von dem renommierten Informatiker Robert J. Martin, bekannt als Uncle Bob, in einem seiner Artikel im Jahr 2000 vorgestellt. Das Akronym Solid, wie wir es kennen, wurde jedoch erst später von Michael Feathers eingeführt. 

Onkel Bob ist in der Tat ein Spezialist auf diesem Gebiet, und zwar so sehr, dass er Bestseller wie Clean Code und Clean Architecture veröffentlicht hat, die sein fortgeschrittenes Wissen über saubere Kodierung, Entwurfsmuster und objektorientierte Architektur belegen. 

Was sind die soliden Prinzipien?

Schauen wir uns die soliden Prinzipien einmal genauer an: 

1. Einzelne Verantwortung

Wir beginnen mit dem Prinzip der einzigen Verantwortung, das besagt, dass eine Klasse etwas Bestimmtes tun muss und nur einen Grund für eine Änderung haben darf. Das heißt, nur eine Änderung der Programmspezifikation kann sich auf die Spezifikation der Klasse auswirken. 

Wenn also eine Klasse ein Datencontainer ist, wie z. B. eine Schülerklasse, und sich darauf beziehende Felder hat, sollte sie sich nur ändern, wenn wir das Datenmodell ändern. 

Warum ist es nun wichtig, das Prinzip der einzigen Verantwortung zu befolgen? Da viele Teams gleichzeitig an demselben Projekt arbeiten und es bearbeiten können, könnten verschiedene inkompatible Module entstehen. 

Andererseits wird dadurch die Versionskontrolle erleichtert. Stellen Sie sich vor, wir haben eine Persistenzklasse, die die gesamte Datenbank verwaltet, und von einem Moment zum anderen sehen wir eine Änderung in der Commits-Datei. 

Wenn wir dann das PRU-Protokoll befolgen, werden wir verstehen, wann es mit der Speicherung oder der Datenbank im Allgemeinen zu tun hat. 

2. Offen-geschlossen

Es besagt, dass Klassen immer offen für Erweiterungen und geschlossen für jede Andeutung einer Änderung sein müssen. 

Was aber ist eine Änderung? Alles, was mit der Änderung des Codes einer bestehenden Klasse zu tun hat, während Erweiterung das Hinzufügen einer neuen Funktion bedeutet. 

In diesem Sinne erklärt das Prinzip, dass wir in der Lage sein sollten, neue Funktionen hinzuzufügen, ohne den Code der Klasse überhaupt zu berühren, denn jedes Mal, wenn wir den Code ändern, laufen wir Gefahr, einen neuen Fehler zu erzeugen. Aus diesem Grund ist es ideal, den getesteten und vertrauenswürdigen Produktionscode nicht anzurühren. 

Um nun eine neue Funktion hinzuzufügen, ohne die Klasse zu berühren, benötigen wir Schnittstellen und abstrakte Klassen.

3. Liskov-Substitution

Andererseits zeigt das Liskovsche Substitutionsprinzip, dass Unterklassen nur durch ihre Basisklasse ersetzt werden sollten. Kurz gesagt bedeutet dies, dass wir in Anbetracht der Tatsache, dass Klasse B eine Unterklasse von A ist, in der Lage sein sollten, ein Element der Klasse B in eine andere Methode zu verschieben, die ein Objekt der Klasse A erwartet.

Nehmen wir an, dass dies das erwartete Verhalten ist, da wir bei der Vererbung davon ausgehen, dass die Unterklasse alles bekommt, was die Oberklasse hat. 

Wenn sich eine Klasse also nicht an dieses Prinzip hält, wird sie einige unangenehme Fehler erzeugen, die Sie nur schwer entdecken können. 

4. Schnittstellentrennung

Das vierte Prinzip ist die Schnittstellentrennung, die darauf abzielt, die Schnittstellen getrennt zu halten. 

Einfach ausgedrückt, besagt dieser Grundsatz, dass mehrere benutzerspezifische Schnittstellen viel besser sind als eine Universalschnittstelle. Daher sollten wir Kunden nicht zwingen, eine Funktion auszuführen, die sie definitiv nicht benötigen. 

5. Invertierung von Abhängigkeiten

Schließlich gibt es noch das Prinzip der Abhängigkeitsinversion, das besagt, dass Klassen von abstrakten Klassen und nicht von konkreten Funktionen abhängen sollten. 

Die Idee ist also, dass Klassen offen für Erweiterungen sind, also organisieren wir unsere Abhängigkeiten so, dass sie nur von Schnittstellen abhängen. 

Vorteile der soliden Prinzipien

Es gibt viele Vorteile, die solide Prinzipien für unsere tägliche Arbeit als Entwickler mit sich bringen. Es ist wichtig, die Tatsache zu schätzen, dass sie uns die Eigenschaften bieten, die wir in einem Qualitätsprogramm sehen wollen. 

Sehen wir uns im Folgenden einige der Vorteile an: 

1. Flexiblere Software

Zunächst einmal müssen wir sagen, dass wir mit diesen Prinzipien eine viel flexiblere Software erhalten. Was wir als Programmierer suchen, ist, dass die Klassen im Code die Fähigkeit haben, unabhängig zu arbeiten, und dass die Änderung die anderen Elemente so wenig wie möglich beeinflusst. 

Wenn zwei Klassen miteinander verbunden sind, um zusammenzuarbeiten, gibt es natürlich eine gute Kopplung zwischen ihnen, und das ist es, wonach wir suchen. 

Da es jedoch verschiedene Ebenen der Kopplung und feste Prinzipien gibt, können wir die Abhängigkeiten lockern, um sie flexibler zu gestalten. 

2. Sie werden die Architekturen besser verstehen

Zweitens werden wir die Strukturen viel besser verstehen, weil die Prinzipien erklären, wie sie funktionieren. 

Das ist eine gute Nachricht für unerfahrene Programmierer, die etwas mehr Zeit brauchen, um dieses Thema zu verstehen. 

3. Leichtere Testerstellung

Mit den soliden Prinzipien lassen sich Tests viel einfacher durchführen. 

Denn wenn wir die Prinzipien gut anwenden, werden wir den Code besser organisieren, was uns ermöglicht, die Architektur besser zu definieren, was das Testen erleichtert. 

Zweifellos gibt es viele Elemente, die bei der Erstellung von Software von Grund auf berücksichtigt werden müssen. 

Heute möchten wir Ihnen einen Überblick darüber geben, was solide Prinzipien bedeuten, damit Sie eine Plattform erstellen können, die den neuesten Trends entspricht. 

Sind Sie bereit, den nächsten Schritt zu tun?