How do interfaces enable polymorphism and support dependency injection?

How do interfaces enable polymorphism and support dependency injection?

• A. Interfaces define contracts that multiple implementations can share; dependencies can be swapped at runtime, enabling loose coupling and testability
• B. Interfaces require global state
• C. Interfaces provide concrete behavior only
• D. Interfaces enforce single implementation

Answer: (A)

Interfaces establish a contract that different classes can implement, which makes polymorphism possible. When code relies on an interface rather than a specific class, the same operations work with any concrete implementation of that interface. That means you can swap in a different behavior without changing the code that uses the interface, simply by providing another implementation at runtime. Dependency injection takes this a step further. A component declares a dependency on the interface, not a concrete class, and an external mechanism (like a DI container or manual wiring) supplies a concrete implementation. This lets you switch between implementations—such as a real service in production and a mock or stub in tests—without touching the dependent code, promoting loose coupling and easier testing. Think of a logger interface with a log method. You could have a ConsoleLogger, a FileLogger, or a RemoteLogger, all implementing that interface. The rest of the system just calls log, unaware of which specific logger is used. The dependency injection setup decides which logger to inject, and you can change it as needed. Interfaces do not require global state, nor do they provide concrete behavior or enforce a single implementation. They define the surface (the contract) and allow multiple implementations to coexist, enabling polymorphism and flexible dependency wiring.

Interfaces establish a contract that different classes can implement, which makes polymorphism possible. When code relies on an interface rather than a specific class, the same operations work with any concrete implementation of that interface. That means you can swap in a different behavior without changing the code that uses the interface, simply by providing another implementation at runtime.

Dependency injection takes this a step further. A component declares a dependency on the interface, not a concrete class, and an external mechanism (like a DI container or manual wiring) supplies a concrete implementation. This lets you switch between implementations—such as a real service in production and a mock or stub in tests—without touching the dependent code, promoting loose coupling and easier testing.

Think of a logger interface with a log method. You could have a ConsoleLogger, a FileLogger, or a RemoteLogger, all implementing that interface. The rest of the system just calls log, unaware of which specific logger is used. The dependency injection setup decides which logger to inject, and you can change it as needed.

Interfaces do not require global state, nor do they provide concrete behavior or enforce a single implementation. They define the surface (the contract) and allow multiple implementations to coexist, enabling polymorphism and flexible dependency wiring.