D - Dependency Inversion Principle(DIP)

Before understanding DIP (Dependency Inversion Principle), it's important to know what High-Level and Low-Level modules and abstractions are.

High-Level Module:

A high-level module refers to the parts of an application that manage core features or business logic. These modules usually handle larger and more critical functions of the application. High-level modules generally perform broader and more complex tasks, and they might depend on other modules to get their work done.

For example, if you're building an e-commerce application, the Order Management System would be a high-level module. It handles major tasks such as taking orders, processing them, managing deliveries, and so on.

Low-Level Module:

Low-level modules, on the other hand, are responsible for specific and smaller tasks. These modules work at a fundamental level of the application and perform more detailed work, like storing data in the database, configuring network settings, etc. Low-level modules typically help the high-level modules carry out their tasks.

Continuing with the e-commerce example, the Payment Gateway Integration would be a low-level module. Its job is specifically to process payments, which is a more specialized task in comparison to the broader functionalities of the order management system.

Abstraction:

In simple terms, abstraction refers to a general idea or representation of a system or process. It defines what should happen but does not specify how it will happen. It focuses on the essential functionality without delving into the underlying implementation details.

Example:

Imagine you are going to drive a car. The concept of driving the car (i.e., abstraction) includes:

• Starting the car
• Stopping the car

However, the abstraction doesn't specify how these actions will be performed. It doesn't tell you what type of car it is, what kind of engine it has, or the specific mechanisms that make the car start or stop. It only provides the general idea of what needs to be done.

Abstraction in Software Design:

In software design, abstraction means creating a general contract or structure using an interface or an abstract class that defines a set of rules or actions, but the specific implementation of those actions is left separate. This allows you to define what needs to be done without specifying how it will be done.

Example:

You could have a PaymentInterface that declares a method for processing payments. The interface specifies that a payment must be processed, but it doesn't define how the payment will be processed. That can be done through different implementations such as PayPal, Stripe, or other payment methods.

In essence, abstraction focuses on the general functionality while leaving the implementation flexible, making it easier to change or extend in the future.

What is Dependency Inversion Principle(DIP) ?

According to the Dependency Inversion Principle (DIP), high-level modules should not depend directly on low-level modules. Instead, both should rely on abstractions, such as interfaces or abstract classes. This allows both high-level and low-level modules to work independently of each other, making the system more flexible and reducing the impact of changes.

Simplified Explanation:

Imagine you have an application with multiple features. If one feature directly depends on another, then modifying one will require changes across many parts of the code. The DIP suggests that instead of direct dependency, you should make different parts of your application work through a common interface or abstraction. This way, each module can function independently, and changes to one feature will have minimal impact on the rest of the system.

Two Key Points of DIP:

• High-level modules should not depend on low-level modules. Instead, both should rely on abstractions.

• There should be a dependency on abstractions, not on concrete (specific implementations).

Example:

Consider a payment system where you can use both PayPal and Stripe as payment methods. If you work directly with PayPal or Stripe, adding a new payment gateway later would require extensive code changes throughout your application.

However, if you follow DIP, you would use a general PaymentInterface. Both PayPal and Stripe would implement this interface. This way, if you want to add a new payment gateway in the future, you simply need to implement the existing interface, making the process much easier.

By following this principle, DIP enhances the maintainability and flexibility of your code, allowing for smoother adaptations and extensions without major disruptions.

Example 1:

Let's consider an application where you need to start and stop different types of vehicles. You can create a Vehicle interface that serves as an abstraction. Any vehicle can implement this interface to provide its own functionality.

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

Explanation:

Here, Vehicle serves as an abstraction that specifies what actions need to be performed (i.e., start and stop), but it does not define how those actions should be executed. The Car and Bike classes implement these methods according to their own logic. This design allows for the easy addition of new vehicle types, such as Truck, without altering the existing code.

Adding a New Vehicle: Truck
To add a new vehicle, you simply need to create a Truck class that implements the Vehicle interface and provides its own implementation of the start() and stop() methods.

Java Code for Truck:

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

Using Truck in the Main Class Without Any Changes:
Now, to include the Truck in the Main class, you can create an instance of Truck and use it as a Vehicle. No changes are necessary in the Main class or any other parts of the code.

Java Code for Main Class:

<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='brush:php;toolbar:false;'>    Vehicle bike = new Bike(); // Bike as Vehicle
    bike.start();
    bike.stop();

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

}

Output:
Copy code
Car started
Car stopped
Bike started
Bike stopped
Truck started
Truck stopped