Förklara Open/Closed Principle på djupet.

Question

Accepted Answer

**Open/Closed Principle (OCP)** säger att programvaruenheter bör vara **öppna för utökning men stängda för ändringar**: du bör lägga till nytt beteende genom att lägga till ny kod, inte genom att redigera befintlig, testad kod.

## Lukten OCP riktar sig mot

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

Varje ny typ tvingar en ändring i en växande `if/elif`-kedja — fragil och en magnet för buggar.

## OCP via polymorfism

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

Att lägga till `Triangle` kräver **noll ändringar** till `total_area` — utökning utan ändringar.

## Mekanismer som möjliggör OCP

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

## Fallgrop

OCP gjord spekulativt blir över-engineering — abstraktioner byggda för variation som aldrig kommer. Tillämpa det där förändring är *sannolikt* ("regeln om tre": abstrahera efter att variationen faktiskt visas upp).

## Varför det är viktigt

Att redigera väl testad kod för att lägga till en funktion riskerar regressioner i allt som koden redan stöder; OCP begränsar nytt beteende till nya, isolerade enheter.

Det är principen bakom utökningsbara ramverk och plugin-system — och det beror på LSP, eftersom utbytbara subtyper är det som gör den "stängda" kärnan säker att lämna orörda.