How IoC Promotes Loose Coupling

Direct Answer

IoC reduces coupling because a class receives collaborators instead of choosing how to construct them. Its constructor makes requirements visible, and configuration can select an implementation. Depending on an interface is useful when there are meaningful alternatives, but DI also works with concrete classes; creating an interface for every class is not required for loose, testable code.

Code Example

// Tight coupling — UserService hardcoded to EmailService
class UserServiceTight {
    private EmailService emailService = new EmailService(); // Cannot swap or test

    public void registerUser(String email) {
        emailService.send(email, "Welcome!");
    }
}

// Loose coupling — depends on interface, implementation injected
interface NotificationService {
    void send(String recipient, String message);
}

@Service
class UserService {
    private final NotificationService notificationService;

    // Spring injects any NotificationService implementation
    public UserService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void registerUser(String email) {
        notificationService.send(email, "Welcome!"); // Works with any implementation
    }
}

@Service
class EmailNotificationService implements NotificationService {
    public void send(String recipient, String message) { /* send email */ }
}

Common Mistakes & Pitfalls

• Depending on concrete classes instead of interfaces: Freshers inject EmailService directly instead of NotificationService interface. This limits flexibility — you can't swap implementations without changing the consumer. Always code to interfaces.
• Creating dependencies with new inside beans: Using new EmailService() defeats IoC. Spring can't manage or replace that instance. Let Spring inject all collaborators.
• Thinking loose coupling means zero dependencies: Loose coupling doesn't eliminate dependencies — it eliminates control over their creation. UserService still depends on NotificationService, but it doesn't create or configure it.
• Not leveraging constructor injection: Some freshers use field injection, which hides dependencies and makes testing harder. Constructor injection makes dependencies explicit and enables immutability.