D - Principe d'inversion de dépendance (DIP)

Bevor Sie DIP (Dependency Inversion Principle) verstehen, ist es wichtig zu wissen, was High-Level- und Low-Level-Module und Abstraktionen sind.

High-Level-Modul:

Ein High-Level-Modul bezieht sich auf die Teile einer Anwendung, die Kernfunktionen oder Geschäftslogik verwalten. Diese Module übernehmen normalerweise größere und kritischere Funktionen der Anwendung. High-Level-Module führen im Allgemeinen umfassendere und komplexere Aufgaben aus und sind möglicherweise auf andere Module angewiesen, um ihre Arbeit zu erledigen.

Zum BeispielWenn Sie eine E-Commerce-Anwendung erstellen, wäre das Auftragsverwaltungssystem ein High-Level-Modul. Es übernimmt wichtige Aufgaben wie die Annahme von Bestellungen, deren Bearbeitung, die Verwaltung von Lieferungen usw.

Low-Level-Modul:

Low-Level-Module sind hingegen für spezifische und kleinere Aufgaben zuständig. Diese Module arbeiten auf einer grundlegenden Ebene der Anwendung und führen detailliertere Arbeiten aus, z. B. das Speichern von Daten in der Datenbank, das Konfigurieren von Netzwerkeinstellungen usw. Low-Level-Module unterstützen normalerweise die High-Level-Module bei der Ausführung ihrer Aufgaben.

Um mit dem E-Commerce-Beispiel fortzufahren: Die Payment Gateway-Integration wäre ein Low-Level-Modul. Seine Aufgabe besteht insbesondere darin, Zahlungen abzuwickeln, was im Vergleich zu den umfassenderen Funktionalitäten des Auftragsverwaltungssystems eine speziellere Aufgabe ist.

Abstraktion:

Einfach ausgedrückt bezieht sich Abstraktion auf eine allgemeine Idee oder Darstellung eines Systems oder Prozesses. Es definiert, was passieren soll, gibt aber nicht an, wie es passieren wird. Es konzentriert sich auf die wesentliche Funktionalität, ohne sich mit den zugrunde liegenden Implementierungsdetails zu befassen.

Beispiel:

Stellen Sie sich vor, Sie würden ein Auto fahren. Das Konzept des Autofahrens (d. h. Abstraktion) umfasst:

• Auto starten
• Auto anhalten

Die Abstraktion gibt jedoch nicht an, wie diese Aktionen ausgeführt werden. Es sagt Ihnen nicht, um welche Art von Auto es sich handelt, welche Art von Motor es hat oder welche spezifischen Mechanismen das Auto starten oder stoppen. Es vermittelt nur eine allgemeine Vorstellung davon, was getan werden muss.

Abstraktion im Softwaredesign:

Abstraktion bedeutet im Softwaredesign die Erstellung eines allgemeinen Vertrags oder einer Struktur mithilfe einer Schnittstelle oder einer abstrakten Klasse, die eine Reihe von Regeln oder Aktionen definiert, die spezifische Implementierung dieser Aktionen jedoch getrennt bleibt. Auf diese Weise können Sie definieren, was getan werden muss, ohne anzugeben, wie es erledigt werden soll.

Beispiel:

Sie könnten ein PaymentInterface haben, das eine Methode zur Verarbeitung von Zahlungen deklariert. Die Schnittstelle gibt an, dass eine Zahlung verarbeitet werden muss, definiert jedoch nicht, wie die Zahlung verarbeitet wird. Dies kann über verschiedene Implementierungen wie PayPal, Stripe oder andere Zahlungsmethoden erfolgen.

Im Wesentlichen konzentriert sich die Abstraktion auf die allgemeine Funktionalität, während die Implementierung flexibel bleibt, sodass sie in Zukunft einfacher geändert oder erweitert werden kann.

Was ist das Abhängigkeitsinversionsprinzip (DIP)?

Gemäß dem Dependency Inversion Principle (DIP) sollten High-Level-Module nicht direkt von Low-Level-Modulen abhängen. Stattdessen sollten beide auf Abstraktionen wie Schnittstellen oder abstrakten Klassen basieren. Dadurch können sowohl High-Level- als auch Low-Level-Module unabhängig voneinander arbeiten, was das System flexibler macht und die Auswirkungen von Änderungen verringert.

Vereinfachte Erklärung:

Stellen Sie sich vor, Sie haben eine Anwendung mit mehreren Funktionen. Wenn eine Funktion direkt von einer anderen abhängig ist, erfordert die Änderung einer Funktion Änderungen in vielen Teilen des Codes. Das DIP schlägt vor, dass Sie anstelle einer direkten Abhängigkeit dafür sorgen sollten, dass verschiedene Teile Ihrer Anwendung über eine gemeinsame Schnittstelle oder Abstraktion funktionieren. Auf diese Weise kann jedes Modul unabhängig funktionieren und Änderungen an einer Funktion haben nur minimale Auswirkungen auf den Rest des Systems.

Zwei wichtige Punkte von DIP:

• High-Level-Module sollten nicht von Low-Level-Modulen abhängen. Stattdessen sollten sich beide auf Abstraktionen verlassen.

• Es sollte eine Abhängigkeit von Abstraktionen bestehen, nicht von konkreten (spezifischen Implementierungen).

Beispiel:

Erwägen Sie ein Zahlungssystem, bei dem Sie sowohl PayPal als auch Stripe als Zahlungsmethoden verwenden können. Wenn Sie direkt mit PayPal oder Stripe arbeiten, würde das spätere Hinzufügen eines neuen Zahlungsgateways umfangreiche Codeänderungen in Ihrer gesamten Anwendung erfordern.

Wenn Sie jedoch DIP folgen, würden Sie eine allgemeine Zahlungsschnittstelle verwenden. Sowohl PayPal als auch Stripe würden diese Schnittstelle implementieren. Wenn Sie also in Zukunft ein neues Zahlungsgateway hinzufügen möchten, müssen Sie lediglich die vorhandene Schnittstelle implementieren, was den Prozess erheblich vereinfacht.

En suivant ce principe, DIP améliore la maintenabilité et la flexibilité de votre code, permettant des adaptations et des extensions plus fluides sans perturbations majeures.

Exemple 1 :

Considérons une application dans laquelle vous devez démarrer et arrêter différents types de véhicules. Vous pouvez créer une interface Vehicle qui sert d'abstraction. N'importe quel véhicule peut implémenter cette interface pour fournir sa propre fonctionnalité.

Code Java :

 // Abstraction: Vehicle interface
interface Vehicle {
    void start();
    void stop();
}

// Car class implements Vehicle interface
class Car implements Vehicle {
    public void start() {
        System.out.println("Car started");
    }

    public void stop() {
        System.out.println("Car stopped");
    }
}

// Bike class implements Vehicle interface
class Bike implements Vehicle {
    public void start() {
        System.out.println("Bike started");
    }

    public void stop() {
        System.out.println("Bike stopped");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car(); // Car as Vehicle
        car.start();
        car.stop();

        Vehicle bike = new Bike(); // Bike as Vehicle
        bike.start();
        bike.stop();
    }
}

Explication:

Ici, Vehicle sert d'abstraction qui spécifie quelles actions doivent être effectuées (c'est-à-dire démarrer et arrêter), mais il ne définit pas comment ces actions doivent être exécutées. Les classes Auto et Bike mettent en œuvre ces méthodes selon leur propre logique. Cette conception permet l'ajout facile de nouveaux types de véhicules, tels que les camions, sans modifier le code existant.

Ajout d'un nouveau véhicule : camion
Pour ajouter un nouveau véhicule, il vous suffit de créer une classe Truck qui implémente l'interface Vehicle et fournit sa propre implémentation des méthodes start() et stop().

Code Java pour camion :

class Truck implements Vehicle {
    public void start() {
        System.out.println("Truck started");
    }
    public void stop() {
        System.out.println("Truck stopped");
    }
}

Utilisation du camion dans la classe principale sans aucun changement :
Désormais, pour inclure le Truck dans la classe Main, vous pouvez créer une instance de Truck et l'utiliser comme véhicule. Aucune modification n'est nécessaire dans la classe Main ou dans toute autre partie du code.

Code Java pour la classe principale :

<p>public class Main {<br>
    public static void main(String[] args) {<br>
        Vehicle car = new Car(); // Car as Vehicle<br>
        car.start();<br>
        car.stop();</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext">    Vehicle bike = new Bike(); // Bike as Vehicle
    bike.start();
    bike.stop();

    // Adding Truck
    Vehicle truck = new Truck(); // Truck as Vehicle
    truck.start();
    truck.stop();
}

}

Sortie :
Copier le code
La voiture a démarré
Voiture arrêtée
Vélo démarré
Vélo arrêté
Camion démarré
Camion arrêté