Suggest an editImprove this articleRefine the answer for “Why does OCP reduce coupling?”. Your changes go to moderation before they’re published.Approval requiredContentWhat you’re changing🇺🇸EN🇺🇦UAPreviewTitle (EN)Short answer (EN)**OCP reduces coupling** because it forces the system to depend on abstractions rather than concrete implementations, and moves the variable logic into separate, extensible modules. **Key point:** modules interact through stable abstractions, and variable logic is moved out into separate, extensible components, which breaks rigid dependencies.Shown above the full answer for quick recall.Answer (EN)ImageOCP 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.**For the reviewerNote to the moderator (optional)Visible only to the moderator. Helps review go faster.