SOLID Prinzipien Grundlagen

SOLID ist ein Akronym für fünf Prinzipien objektorientierten Designs, die zu wartbarem, erweiterbarem und fehlerresistentem Code führen.

In a Nutshell

SOLID: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.

S — Single Responsibility (SRP)

Eine Klasse sollte nur einen Grund zur Änderung haben.

// Schlecht: mehrere Verantwortungen
class User {
  saveToDatabase() { /* DB */ }
  sendEmail() { /* E-Mail */ }
  validateEmail() { /* Validierung */ }
}

// Gut: getrennt
class User {}
class UserRepository { save(u: User) {} }
class EmailService { send(u: User, msg: string) {} }

O — Open-Closed (OCP)

Offen für Erweiterung, geschlossen für Modifikation.

// Schlecht: Switch bei neuem Typ erweitern
class DiscountCalculator {
  calculate(type: string): number {
    if (type === 'premium') return 0.8;
    if (type === 'vip') return 0.7;
    return 1.0;
  }
}

// Gut: Strategy Pattern
interface DiscountStrategy { getFactor(): number; }
class PremiumDiscount implements DiscountStrategy { getFactor() { return 0.8; } }
class VipDiscount implements DiscountStrategy { getFactor() { return 0.7; } }

L — Liskov Substitution (LSP)

Subtypen müssen Basistypen ersetzen können.

// Schlecht: Penguin kann nicht fliegen
class Bird { fly() {} }
class Penguin extends Bird { fly() { throw new Error('Cannot fly'); } }

// Gut: korrekte Hierarchie
interface Bird { layEgg(): void; }
interface FlyingBird extends Bird { fly(): void; }

I — Interface Segregation (ISP)

Kein Client sollte von ungenutzten Methoden abhängen.

// Schlecht: fettes Interface
interface Worker { work(): void; eat(): void; sleep(): void; }

// Gut: getrennt
interface Workable { work(): void; }
interface Eatable { eat(): void; }

D — Dependency Inversion (DIP)

Abhängig von Abstraktionen, nicht von Konkretionen.

// Schlecht: direkte Abhängigkeit
class OrderService {
  private repo = new MySQLDatabase();
}

// Gut: Dependency Injection
interface OrderRepository { save(order: Order): void; }
class OrderService {
  constructor(private repo: OrderRepository) {}
}

SOLID im Überblick

Prinzip	Bedeutung	Ziel
SRP	Single Responsibility	Eine Klasse, eine Verantwortung
OCP	Open-Closed	Erweiterbar ohne Modifikation
LSP	Liskov Substitution	Subtypen ersetzen Basistypen
ISP	Interface Segregation	Kleine, spezifische Interfaces
DIP	Dependency Inversion	Abstraktion statt Konkretion

Prüfungsrelevante Stichpunkte

• SOLID als Akronym für fünf OOP-Designprinzipien
• SRP: ein Grund zur Änderung pro Klasse
• OCP: Erweiterung ohne Modifikation (Strategy Pattern)
• LSP: Subtypen müssen Verträge einhalten
• ISP: Viele kleine Interfaces
• DIP: Dependency Injection, Abstraktion als Abhängigkeit

FAQ

Weiter im SOLID Lernpfad

Der nächste Artikel im SOLID Lernpfad behandelt Analyse- und Designverfahren: UML, GRASP, SOLID und Qualitätsziele — wie UML-Diagramme, GRASP-Patterns und SOLID-Prinzipien in der Softwarearchitektur zusammenwirken.

Quellen

1. https://en.wikipedia.org/wiki/SOLID
2. https://www.oreilly.com/library/view/clean-code/9780134661742/
3. https://refactoring.guru/design-patterns/solid-principles

Buchempfehlungen zur Softwarequalität

Wenn Du Dich weiter mit SOLID, Clean Code und Softwarequalität beschäftigen möchtest, empfehlen wir Dir die folgenden Bücher: