Объясните принцип Open/Closed в деталях.

Question

Accepted Answer

**Open/Closed Principle (OCP)** гласит, что программные сущности должны быть **открыты для расширения, но закрыты для модификации**: новое поведение следует добавлять, создавая новый код, а не редактируя существующий, протестированный код.

## Запах кода, на который нацелен OCP

```python
# CLOSED to extension: every new shape edits this method (risky, retests everything)
def area(shape):
    if shape.kind == "circle":   return 3.14159 * shape.r ** 2
    elif shape.kind == "square": return shape.s ** 2
    elif shape.kind == "rect":   return shape.w * shape.h
    # add a triangle → modify this function again...
```

Каждый новый тип требует изменения растущей цепочки `if/elif` — это хрупко и привлекает ошибки.

## OCP через полиморфизм

```python
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self): ...

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

class Triangle(Shape):                 # NEW behavior = NEW class
    def __init__(self, b, h): self.b, self.h = b, h
    def area(self): return 0.5 * self.b * self.h

def total_area(shapes):                # never changes again
    return sum(s.area() for s in shapes)
```

Добавление `Triangle` требует **нулевых редактирований** `total_area` — расширение без модификации.

## Механизмы, которые включают OCP

```text
→ polymorphism / inheritance     → strategy pattern (inject behavior)
→ plugins / interfaces           → higher-order functions / callbacks
```

## Ловушка

OCP, применённый спекулятивно, превращается в переинжинеринг — абстракции, созданные для вариаций, которые никогда не появятся. Применяйте его там, где изменения *вероятны* ("правило трёх": абстрагируйте после того, как вариация действительно появится).

## Почему это важно

Редактирование протестированного кода для добавления функции рискует вызвать регрессии во всём, что этот код уже поддерживает; OCP ограничивает новое поведение новыми, изолированными единицами.

Это принцип, лежащий в основе расширяемых фреймворков и систем плагинов — и он зависит от LSP, поскольку подставляемые подтипы — это то, что делает закрытое ядро безопасным для оставления нетронутым.