Explicați în profunzime Principiul Open/Closed.

Question

Accepted Answer

**Principiul Open/Closed (OCP)** spune că entitățile software ar trebui să fie **deschise pentru extindere dar închise pentru modificare**: ar trebui să adăugați comportament nou adăugând cod nou, nu prin editarea codului existent și testat.

## Problema pe care o vizează 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...
```

Fiecare tip nou forțează o schimbare într-un lanț `if/elif` în creștere — fragil și un magnet pentru erori.

## OCP prin polimorfism

```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)
```

Adăugarea `Triangle` necesită **zero modificări** la `total_area` — extindere fără modificare.

## Mecanisme care activează OCP

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

## Capcană

OCP făcut speculativ devine supra-inginerie — abstracții construite pentru variație care niciodată nu apare. Aplicați-l unde schimbarea este *probabilă* ("regula trei": abstractizați după ce variația se întâmplă de fapt).

## De ce contează

Editarea codului testat în luptă pentru a adăuga o funcționalitate riscă regresii în totul ceea ce acel cod deja suportă; OCP limitează comportamentul nou la unități noi și izolate.

Este principiul din spatele framework-urilor extensibile și a sistemelor de plugin — și depinde de LSP, deoarece subtipuri substituibile sunt ceea ce face ca nucleul "închis" să fie sigur de a-l lăsa netouched.