19.3.1. Constructor Injection

Dependencies are passed via constructor parameters.

class Engine {
    public void start() {
        System.out.println("Engine started.");
    }
}
class Car {
    private Engine engine;
    public Car(Engine engine) {
        this.engine = engine;
    }
    public void drive() {
        engine.start();
        System.out.println("Car is driving.");
    }
}

Constructor injection is a method of providing an object’s dependencies through its constructor. In our example, we have an Engine class that has a method called start(). The Car class has a private field of type Engine and requires an Engine object to be passed to it during the creation of a Car object. Notice that when the Car object is created, we pass an Engine object as a parameter, effectively injecting the Engine dependency into the Car. The drive() method of Car then uses that injected Engine to start it and drive the car.

Think about buying a car. When you purchase a car, it comes with a certain engine type that the manufacturer provides. You can’t just choose any engine; the car is designed to work with a specific engine type. Similarly, in constructor injection, the Car class is designed to work with a specific Engine type, which it receives right when it is created.

Constructor injection provides a clear way to declare dependencies, promotes immutability where possible, and ensures that the object is in a fully initialized state once constructed.

Using constructor injection allows developers to explicitly state what dependencies a class needs through its constructor. This makes the dependencies clear and helps to enforce immutability, which means that once an object is created, its dependencies cannot be changed. It also ensures that when you create an instance of a class, all necessary dependencies are provided at that time, reducing the risk of errors associated with uninitialized or incorrectly set properties.

Imagine a recipe for a cake. The recipe tells you exactly what ingredients you need to prepare the cake. If some ingredients are missing or measured incorrectly during the preparation, you might end up with a bad cake. Constructor injection is similar; it clearly specifies what is necessary for the object (the Cake in this analogy) to be ready and functioning correctly.

--