What is Dependency Injection (DI)?

Dependency Injection (DI) is a software design pattern that allows for loose coupling between classes and their dependencies. It does this by decoupling the usage of an object from its creation. This makes code more reusable, testable, and maintainable.

In Dependency Injection (DI) , you don't create the objects that your code needs. Instead, you inject them into your code. This is done through the constructor of the object, or through a setter method.

Simple definition of Dependency Injection (DI) in points:

• Dependency: A resource that a given piece of code requires.
• Injection: The process of supplying a dependency to a piece of code, rather than being created internally.
• Dependency Injection: The process of supplying a dependency to a piece of code without having to create it ourselves.

DI is useful for a number of reasons, including:

• Loose coupling: DI helps to make code more loosely coupled, which means that classes are less dependent on each other. This makes code more reusable and easier to test.
• Testability: DI makes code more testable because we can easily mock or stub out dependencies for testing purposes.
• Maintainability: DI makes code more maintainable because it makes it easier to change the implementation of dependencies without having to change the code that uses them.

---

Simple example of DI

Let's say we have a class called Car that depends on a class called Engine. Without DI, the Car class would create its own Engine object. This would make the Car class less reusable, because it would only be able to work with a specific type of Engine.

With DI, we can pass the Engine object to the Car class when it is created. This makes the Car class more reusable, because it can now work with any type of Engine object that is passed to it.

// Define the Engine class
class Engine {
    // Method to start the engine
    void start() {
        System.out.println("Engine starting...");
    }
}

// Define the Car class
class Car {
    private Engine engine; // Declare an instance variable to hold the Engine object

    // Constructor that takes an Engine object as a parameter
    Car(Engine engine) {
        this.engine = engine; // Assign the passed Engine object to the instance variable
    }

    // Method to drive the car
    void drive() {
        engine.start(); // Call the start method of the Engine object
        System.out.println("Car driving...");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create an Engine object
        Engine engine = new Engine();

        // Create a Car object and pass the Engine object to it
        Car car = new Car(engine);

        // Drive the car
        car.drive();
    }
}

Diagram:
        +---------------+
        |    Engine     |
        |---------------|
        | start()       |
        +-------|-------+
                |
                |
                |
                v
        +---------------+
        |     Car       |
        |---------------|
        | engine: Engine|
        |---------------|
        | + Car(engine) |
        | + drive()     |
        +---------------+

Explanation of the example code in points:

1. Engine Class:

   • We define a class called Engine that represents an engine.
   • It has a method start() to simulate starting the engine, and it prints a message.

2. Car Class:

   • We define a class called Car, which represents a car.
   • The Car class has a constructor that takes an Engine object as a parameter.

3. Dependency Injection (DI):

   • DI is demonstrated by passing an Engine object to the Car class when it is created. This allows the Car class to work with any type of Engine object, making it more reusable and flexible.

4. Constructor Injection:

   • In the Car constructor, we use constructor injection to assign the provided Engine object to an instance variable, making it available for use throughout the Car class.

5. Drive Method:

   • The Car class has a drive() method that simulates driving the car.
   • Inside the drive() method, it calls the start() method on the Engine object to start the engine and prints a message indicating that the car is driving.

6. Main Function:

   • In the main function, we create an instance of the Engine class, representing the car's engine.

7. Creating a Car Object:

   • We create a Car object and pass the Engine object as a parameter to the Car constructor, demonstrating how DI allows us to provide dependencies to objects from outside.

8. Driving the Car:

   • Finally, we call the drive() method on the Car object, which starts the engine and prints a message indicating that the car is driving.

9. Benefits of Dependency Injection:

   • This example illustrates the benefits of Dependency Injection in making code more reusable and testable.
   • It allows for the separation of concerns, where the Car class doesn't need to create its own Engine object but relies on an external entity to provide it.

10. Testing:

• DI makes it easier to test components in isolation, as you can provide mock or test-specific implementations of dependencies when testing the Car class.

11. Flexibility:

• With DI, you can easily switch the type of engine or other dependencies used by the Car class without modifying the Car class itself, promoting flexibility and maintainability in your code.