What is dependency inversion?

The Dependency Inversion Principle (DIP) states that:

• High-level modules should not depend on low-level modules. Both should depend on abstractions.
• Abstractions should not depend on details. Details should depend on abstractions.

The essence is that instead of a direct dependency of a high-level module (which defines the overall logic) on a low-level module (which implements details), both should depend on some abstraction (interface or abstract class). This makes the system more flexible, easily testable, and extendable.

Example: Without DIP: A high-level class ReportGenerator directly depends on a low-level class FileDataReader.

// Poor implementation without DIP
class FileDataReader {
    String getData() {
        // Reading from file
        return "file data";
    }
}

class ReportGenerator {
    FileDataReader reader = new FileDataReader();

    void generate() {
        String data = reader.getData();
        System.out.println("Report: " + data);
    }
}

With DIP: ReportGenerator and FileDataReader (or its equivalent) depend on the abstraction DataReader.

// Good implementation with DIP
interface DataReader {
    String getData();
}

class FileDataReader implements DataReader {
    @Override
    public String getData() {
        // Reading from file
        return "file data";
    }
}

class DatabaseDataReader implements DataReader {
     @Override
    public String getData() {
        // Reading from database
        return "database data";
    }
}


class ReportGenerator {
    private final DataReader reader; // Dependency on abstraction

    ReportGenerator(DataReader reader) { // Dependency injection
        this.reader = reader;
    }

    void generate() {
        String data = reader.getData();
        System.out.println("Report: " + data);
    }
}

// Usage:
// ReportGenerator report = new ReportGenerator(new FileDataReader());
// ReportGenerator report = new ReportGenerator(new DatabaseDataReader());

Dependency inversion is often achieved using techniques such as Dependency Injection (DI).