Why does OCP reduce coupling?

OCP reduces coupling because it forces the system to depend on abstractions rather than concrete implementations, and moves variable logic into separate, extensible modules.

In detail:

#1. It removes dependence on concrete classes

When behavior is extended through interfaces or abstractions, modules stop depending on each other directly. Client code knows only the contract (the interface), not the concrete class. This reduces the degree of coupling between components.

#2. Variable parts are moved out of the base code

Without OCP, the base module has to know about every behavior variant (for example, through an if for each type). This creates rigid dependencies: one module depends on many others. With OCP, new functionality is moved into a separate class, and the base code does not know about it. Coupling decreases.

#3. Modules stop affecting each other when changes happen

If an implementation can be changed without touching its consumers, those consumers are "loosely coupled" to it. New requirements no longer require changing client code - this is the key reduction in coupling.

#4. Using polymorphism instead of conditional statements

If a new behavior variant is added through a new interface implementation, client code stays unchanged. If OCP were not followed, the new variant would have to be built in through if/else, creating a tie between modules. Polymorphism breaks these ties.

#5. Fewer points where modules touch each other

When an abstraction defines a single point of interaction, the dependency becomes singular and predictable. Without OCP, one module knows too much about the structure of another - strong coupling.

#6. Flexibility to swap dependencies

Weak coupling shows up in the fact that a different implementation can be substituted in without changing client code. This is achieved directly by the fact that OCP forces behavior to be extended outside existing code.

Summary: OCP reduces coupling because modules interact through stable abstractions, and variable logic is moved out into separate, extensible components. This breaks rigid dependencies and makes the system more flexible.