D – Abhängigkeitsinversionsprinzip (DIP)

Avant de comprendre le DIP (Principe d'inversion de dépendance), il est important de savoir ce que sont les modules et abstractions de haut niveau et de bas niveau.

Module de haut niveau :

Un module de haut niveau fait référence aux parties d'une application qui gèrent les fonctionnalités de base ou la logique métier. Ces modules gèrent généralement des fonctions plus importantes et plus critiques de l'application. Les modules de haut niveau effectuent généralement des tâches plus larges et plus complexes, et ils peuvent dépendre d'autres modules pour faire leur travail.

Par exemple, si vous créez une application de commerce électronique, le système de gestion des commandes serait un module de haut niveau. Il gère les tâches importantes telles que la prise de commandes, leur traitement, la gestion des livraisons, etc.

Module de bas niveau :

Les modules de bas niveau, quant à eux, sont responsables de tâches spécifiques et plus petites. Ces modules fonctionnent à un niveau fondamental de l'application et effectuent un travail plus détaillé, comme stocker des données dans la base de données, configurer les paramètres réseau, etc. Les modules de bas niveau aident généralement les modules de haut niveau à effectuer leurs tâches.

En continuant avec l'exemple du commerce électronique, l'intégration de la passerelle de paiement serait un module de bas niveau. Son travail consiste spécifiquement à traiter les paiements, ce qui est une tâche plus spécialisée par rapport aux fonctionnalités plus larges du système de gestion des commandes.

Abstraction:

En termes simples, l'abstraction fait référence à une idée générale ou à une représentation d'un système ou d'un processus. Il définit ce qui devrait se produire mais ne précise pas comment cela se produira. Il se concentre sur les fonctionnalités essentielles sans entrer dans les détails de mise en œuvre sous-jacents.

Exemple:

Imaginez que vous allez conduire une voiture. Le concept de conduite automobile (c'est-à-dire l'abstraction) comprend :

• Démarrer la voiture
• Arrêter la voiture

Cependant, l'abstraction ne précise pas comment ces actions seront effectuées. Il ne vous indique pas de quel type de voiture il s'agit, de quel type de moteur elle est équipée, ni des mécanismes spécifiques qui font démarrer ou arrêter la voiture. Il donne seulement une idée générale de ce qui doit être fait.

Abstraction dans la conception de logiciels :

Dans la conception de logiciels, l'abstraction signifie la création d'un contrat ou d'une structure générale à l'aide d'une interface ou d'une classe abstraite qui définit un ensemble de règles ou d'actions, mais la mise en œuvre spécifique de ces actions est laissée à part. Cela permet de définir ce qui doit être fait sans préciser comment cela sera fait.

Exemple:

Vous pourriez avoir une PaymentInterface qui déclare une méthode de traitement des paiements. L'interface précise qu'un paiement doit être traité, mais elle ne définit pas comment le paiement sera traité. Cela peut être fait via différentes implémentations telles que PayPal, Stripe ou d'autres méthodes de paiement.

Essentiellement, l'abstraction se concentre sur la fonctionnalité générale tout en laissant la mise en œuvre flexible, ce qui facilite sa modification ou son extension à l'avenir.

Qu'est-ce que le principe d'inversion de dépendance (DIP) ?

Selon le principe d'inversion de dépendance (DIP), les modules de haut niveau ne doivent pas dépendre directement des modules de bas niveau. Au lieu de cela, les deux devraient s'appuyer sur des abstractions, telles que des interfaces ou des classes abstraites. Cela permet aux modules de haut niveau et de bas niveau de fonctionner indépendamment les uns des autres, rendant le système plus flexible et réduisant l'impact des changements.

Explication simplifiée :

Imaginez que vous ayez une application avec plusieurs fonctionnalités. Si une fonctionnalité dépend directement d’une autre, sa modification nécessitera des modifications dans de nombreuses parties du code. Le DIP suggère qu'au lieu d'une dépendance directe, vous devriez faire fonctionner différentes parties de votre application via une interface ou une abstraction commune. De cette façon, chaque module peut fonctionner indépendamment et les modifications apportées à une fonctionnalité auront un impact minimal sur le reste du système.

Deux points clés du DIP :

• Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Au lieu de cela, les deux devraient s'appuyer sur des abstractions.

• Il devrait y avoir une dépendance aux abstractions, pas au concret (implémentations spécifiques).

Exemple:

Envisagez un système de paiement dans lequel vous pouvez utiliser à la fois PayPal et Stripe comme méthodes de paiement. Si vous travaillez directement avec PayPal ou Stripe, l'ajout ultérieur d'une nouvelle passerelle de paiement nécessiterait des modifications importantes du code dans l'ensemble de votre application.

Cependant, si vous suivez DIP, vous utiliserez une interface de paiement générale. PayPal et Stripe implémenteraient cette interface. De cette façon, si vous souhaitez ajouter une nouvelle passerelle de paiement à l'avenir, il vous suffira simplement d'implémenter l'interface existante, ce qui rendra le processus beaucoup plus facile.

Durch die Befolgung dieses Prinzips verbessert DIP die Wartbarkeit und Flexibilität Ihres Codes und ermöglicht reibungslosere Anpassungen und Erweiterungen ohne größere Unterbrechungen.

Beispiel 1:

Betrachten wir eine Anwendung, bei der Sie verschiedene Fahrzeugtypen starten und stoppen müssen. Sie können eine Fahrzeugschnittstelle erstellen, die als Abstraktion dient. Jedes Fahrzeug kann diese Schnittstelle implementieren, um seine eigene Funktionalität bereitzustellen.

Java-Code:

 // 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();
    }
}

Erläuterung:

Hier dient Fahrzeug als Abstraktion, die angibt, welche Aktionen ausgeführt werden müssen (z. B. Starten und Stoppen), aber nicht definiert, wie diese Aktionen ausgeführt werden sollen. Die Klassen Car und Bike implementieren diese Methoden nach ihrer eigenen Logik. Dieses Design ermöglicht das einfache Hinzufügen neuer Fahrzeugtypen, wie z. B. LKW, ohne den vorhandenen Code zu ändern.

Neues Fahrzeug hinzufügen: LKW
Um ein neues Fahrzeug hinzuzufügen, müssen Sie lediglich eine Truck-Klasse erstellen, die die Fahrzeugschnittstelle implementiert und eine eigene Implementierung der Methoden start() und stop() bereitstellt.

Java-Code für LKW:

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

Nutzung von LKW in der Hauptklasse ohne Änderungen:
Um nun den Truck in die Main-Klasse aufzunehmen, können Sie eine Instanz von Truck erstellen und ihn als Fahrzeug verwenden. Es sind keine Änderungen an der Main-Klasse oder anderen Teilen des Codes erforderlich.

Java-Code für Hauptklasse:

<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();
}

}

Ausgabe:
Code kopieren
Auto gestartet
Auto hat angehalten
Fahrrad gestartet
Fahrrad hat angehalten
LKW gestartet
LKW hat angehalten