Kunt u een voorbeeld geven van het gebruik van het principe van afhankelijkheidsomkering in een echte ontwikkeling?

Het Dependency Inversion Principle (DIP) stelt dat hoog-niveau modules niet afhankelijk moeten zijn van laag-niveau modules, maar dat beide afhankelijk moeten zijn van abstracties.

Voorbeeld in Java:

// Abstractie
public interface MessageService {
    void sendMessage(String message);
}

// Concrete implementatie
public class EmailService implements MessageService {
    public void sendMessage(String message) {
        System.out.println("Verzenden email: " + message);
    }
}

// Klasse die afhankelijk is van de abstractie, niet van de concrete implementatie
public class Notification {
    private MessageService service;

    public Notification(MessageService service) {
        this.service = service;
    }

    public void notifyUser(String message) {
        service.sendMessage(message);
    }
}

// Gebruik
public class Main {
    public static void main(String[] args) {
        MessageService emailService = new EmailService();
        Notification notification = new Notification(emailService);
        notification.notifyUser("Hallo!");
    }
}

Hier hangt de Notification klasse af van de MessageService interface, niet van de concrete EmailService. Dit maakt het gemakkelijk om de implementatie te wijzigen (bijvoorbeeld naar een SMS-service) zonder de Notification code te hoeven aanpassen. Deze aanpak verbetert de testbaarheid en uitbreidbaarheid van de code.