Suggest an edit

Improve this article

Refine the answer for “How do you implement OCP through composition?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

OCP through composition is implemented so that **a class is not overridden through inheritance, but instead receives an object that defines the behavior**. New behavior is added by creating new strategies/components, not by changing existing code.

In detail:

## 1. A class gets its dependency through an interface or abstraction
Instead of overriding methods in descendants, the class accepts an object that implements a defined contract.
This object defines the variable behavior.

## 2. The code is closed for modification
The class that uses the dependency does not change.
It simply calls the methods of the injected strategy.

## 3. New behavior is added by creating a new component
To implement a new behavior variant, a new class is created that implements the same interface.
Existing classes remain unchanged - that is what following OCP means.

Example (payment strategy):

Behavior interface:

```python
class PaymentStrategy:
    def pay(self, amount):
        raise NotImplementedError
```

Implementations:

```python
class CardPayment(PaymentStrategy):
    def pay(self, amount):
        print("Card payment:", amount)

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print("PayPal payment:", amount)
```

The class that uses the strategy:

```python
class CheckoutService:
    def __init__(self, payment_strategy: PaymentStrategy):
        self.payment_strategy = payment_strategy

def process(self, amount):
        self.payment_strategy.pay(amount)
```

Extension:

```python
class CryptoPayment(PaymentStrategy):
    def pay(self, amount):
        print("Crypto payment:", amount)
```

## Why this is OCP

1. **CheckoutService never changes.**
It is fully closed for modification.
2. **New behavior is added through new strategies.**
CryptoPayment is a new class that does not require changing the existing system.
3. **Client code simply plugs in a new component.**
For example:

```python
checkout = CheckoutService(CryptoPayment())
checkout.process(100)
```

4. **Composition is more flexible than inheritance.**
Behavior can be swapped at runtime, combined, or changed without creating new class hierarchies.

Summary:
**OCP through composition is implemented using strategies, delegation, and dependency injection: the base code stays unchanged, and new behavior is added by creating new components that are passed into the class from outside.**

Markdown · drag & drop images · ⌘B / ⌘I shortcuts309 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.