How do you achieve Loose Coupling using Interfaces? (Dependency Injection basics)
Loose Coupling with Interfaces and Dependency Injection
Loose coupling means a component depends on abstractions rather than concrete implementations. Interfaces provide the abstraction boundary, while dependency injection supplies the required implementation from outside the dependent class. This makes the component easier to test, replace and evolve. Constructor injection is generally my preferred approach because required dependencies are explicit and the object cannot be constructed without them.
- 1
Depend on an interface rather than a concrete class.
- 2
Inject dependencies instead of constructing them internally.
- 3
Constructor injection makes required dependencies explicit.
- 4
Implementations can be replaced without changing the consumer.
- 5
Testing becomes easier because mocks, stubs or fakes can implement the interface.
- 6
Dependency injection is a design technique; a DI framework is optional.
Scenario Questions
0-2 years experience
- 1We have a class OrderProcessor that directly creates a PaymentGateway instance. How would you refactor it to use an interface and dependency injection?
- 2If you replace the concrete EmailSender with a mock in a unit test, what changes are needed in the code to keep it loosely coupled?
- 3What happens at runtime if you forget to register the implementation of an interface in your DI container?
2-5 years experience
- 1Your new feature adds a logging component, but after wiring it via DI, the application crashes with a circular dependency error. How would you diagnose and fix it?
- 2Explain why injecting a concrete class instead of an interface caused a bug when you swapped out the data repository for a different database.
- 3When a service is being instantiated multiple times despite being registered as a singleton, what could be wrong with your interface usage?
5-8 years experience
- 1Design a plugin architecture for a payment processing system where new payment providers can be added without modifying core code. How would you use interfaces and DI to achieve loose coupling, and what trade‑offs do you consider for performance and startup time?
- 2In a microservices environment, a service depends on an external email service via an interface. How would you handle versioning and backward compatibility while keeping the coupling loose?
- 3Your team notices that the DI container is becoming a bottleneck during high load. What strategies can you employ to keep the system loosely coupled but improve performance?
8+ years experience
- 1Our legacy monolith uses concrete classes everywhere. We need to migrate to a modular architecture with DI. Outline a phased migration plan that introduces interfaces gradually while minimizing risk.
- 2Across multiple teams, different DI frameworks are being used. How would you establish a company‑wide standard for interface‑based injection that balances flexibility and consistency?
- 3When introducing a new cross‑cutting concern like observability via decorators, how do you ensure existing components remain loosely coupled and avoid breaking contracts?
Follow-up Questions
- How would you decide between constructor and property injection in this scenario?
- What are the risks of using a service locator instead of DI?
- Can you give an example of a situation where too many interfaces become a maintenance burden?