SOLID-Programmierprinzipien in der Praxis

Die SOLID-Prinzipien sind grundlegend für die Entwicklung effektiver, wartbarer, objektorientierter Systeme.

Unabhängig davon, ob Sie gerade erst mit dem Schreiben von Software begonnen haben oder dies schon seit Jahren tun, können die SOLID-Prinzipien, wenn sie richtig eingesetzt werden, die Kapselung und Kopplung Ihrer Anwendung verbessern und sie angesichts sich ändernder Anforderungen anpassungsfähiger und testbarer machen.

Die Entwicklung von Software bedeutet eine Menge Arbeit und es ist oft nicht klar, was ein gutes Software-Design ausmacht. Die soliden Designprinzipien sind fünf Ideen, die dabei helfen können, Software zu entwickeln, die leicht zu erweitern und anzupassen ist.

Diese Grundsätze legen Praktiken fest, die sich für die Entwicklung von Software eignen, wobei die Wartung und Erweiterung bei wachsendem Projekt berücksichtigt wird. Die Übernahme dieser Praktiken kann auch zur Vermeidung von Code Smells, zur Refaktorierung von Code und zur agilen oder adaptiven Softwareentwicklung beitragen.

Um SOLID in Ihre eigenen Entwicklungsabläufe zu integrieren, werden die Prinzipien anhand von Beispielen aus der Praxis Schritt für Schritt erläutert. Lernen Sie, wie Sie diese Prinzipien im Entwurfsprozess anwenden und die Stärke Ihres Codes währenddessen testen können.

Einführung in die SOLID-Programmierung

• Vorteile der SOLID-Programmierungsprinzipien
• Überblick über die SOLID-Prinzipien
• CRC-Karten - Entwurfsprozess
• Testgetriebener Entwurf

Prinzip der Schnittstellentrennung (Interface Segregation Principle)

• Einführung in das Prinzip der Schnittstellentrennung
• Objekte des Problembereichs: Einzelne Datenproben
• Sammlungen von Stichproben
• Lesen und Erstellen von Stichproben

Liskov-Substitutions-Prinzip

• Einführung in das Liskov-Substitutionsprinzip
• Duck Typing
• Variationen der Schnittstelle
• Vermeidung von isinstance()

Das Open/Closed Design-Prinzip

• Einführung in das Open/Closed Design Principle
• Modifizieren einer Klasse und Beheben von Fehlern
• OCP durch Vererbung und Komposition
• Weitere OCP-Erweiterungstechniken

Prinzip der Inversion von Abhängigkeiten (Dependency Inversion Principle)

• Einführung in das Prinzip der Abhängigkeitsinversion (Dependency Inversion)
• Injektion von Abhängigkeiten und Anwendungskonfiguration
• Konsequenzen für das Testen

Prinzip der Einzelverantwortung (Single-Responsibility Principle)

• Einführung in die Einzelverantwortung
• GRASP-Muster: Hohe Kohäsion und Indirektion
• Weitere GRASP-Muster

Es gibt viele Grundsätze, die eine gute objektorientierte Gestaltung und Programmierung unterstützen. Fünf dieser Grundsätze werden von SOLID beschrieben: Das Single-Responsibility-Prinzip besagt, dass jede Klasse nur eine einzige Verantwortung haben solle. Verantwortung wird hierbei als "Grund zur Änderung" definiert. Das Open-Closed-Prinzip besagt, dass Software-Einheiten Erweiterungen möglich machen sollen, ohne dabei ihr Verhalten zu ändern. Das Liskovsche Substitutionsprinzip (LSP) oder Ersetzbarkeitsprinzip fordert, dass eine Instanz einer abgeleiteten Klasse sich so verhalten muss, dass jemand, der meint, ein Objekt der Basisklasse vor sich zu haben, nicht durch unerwartetes Verhalten überrascht wird, wenn es sich dabei tatsächlich um ein Objekt eines Subtyps handelt. Das Interface-Segregation-Prinzip dient dazu, zu große Interfaces aufzuteilen. Die Aufteilung soll gemäß den Anforderungen der Clients an die Interfaces gemacht werden, dass die neuen Interfaces genau auf die Anforderungen der einzelnen Clients passen. Das Dependency-Inversion-Prinzip beschäftigt sich mit der Reduktion der Kopplung von Modulen. Es besagt, dass Abhängigkeiten immer von konkreteren Modulen niedriger Ebenen zu abstrakten Modulen höherer Ebenen gerichtet sein sollten. Diese Prinzipien leiten die Erstellung von stabilem, skalierbarem und robustem Software-Code.

Die Weiterbildung "SOLID-Programmierprinzipien in der Praxis" bieten wir Ihnen als Firmenseminar sowie Inhouse-Schulung Live-Online und Vor-Ort an!