Podrobně vysvětlete Open/Closed Principle.

Question

Accepted Answer

**Open/Closed Principle (OCP)** říká, že softwarové entity by měly být **otevřené pro rozšíření, ale zavřené pro modifikaci**: měli byste přidávat nové chování přidáváním nového kódu, nikoli úpravou existujícího, testovaného kódu.

## Vůně, na kterou se OCP zaměřuje

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

Každý nový typ vynutí změnu rostoucího řetězu `if/elif` — křehký a magnet na chyby.

## OCP přes polymorfismus

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

Přidání `Triangle` vyžaduje **nula úprav** `total_area` — rozšíření bez modifikace.

## Mechanismy, které OCP umožňují

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

## Úskalí

OCP dělané spekulativně se stane přeingenerováním — abstrakce vytvořené pro variaci, která nikdy nepřijde. Aplikujte ji tam, kde je změna *pravděpodobná* ("pravidlo tří": abstrahujte poté, co se variace skutečně objeví).

## Proč to je důležité

Úprava důsledně testovaného kódu pro přidání funkce riskuje regrese ve všem, co tento kód již podporuje; OCP omezuje nové chování na nové, izolované jednotky.

Je to princip za rozšiřitelnými frameworky a plug-in systémy — a závisí na LSP, protože nahraditelné podtypy jsou to, co činí "uzavřené" jádro bezpečné k ponechání nedotčeného.