Forklar Open/Closed Principle i dybden.

Question

Accepted Answer

**Open/Closed Principle (OCP)** siger, at softwareenheder skal være **åbne for udvidelse, men lukkede for ændring**: du skal tilføje ny adfærd ved at tilføje ny kode, ikke ved at redigere eksisterende, testet kode.

## Den lugt OCP sigter mod

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

Hver ny type tvinger en ændring til en voksende `if/elif`-kæde — skrøbelig og en magnet for fejl.

## OCP via polymorfisme

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

Tilføjelse af `Triangle` kræver **nul redigeringer** til `total_area` — udvidelse uden ændring.

## Mekanismer, der muliggør OCP

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

## Faldgruppe

OCP gjort spekulativt bliver over-engineering — abstraktioner bygget til variation, der aldrig ankommer. Anvend det, hvor ændring er *sandsynlig* ("reglen om tre": abstrahér efter at variationen faktisk dukker op).

## Hvorfor det betyder noget

At redigere grundigt testet kode for at tilføje en funktion risikerer tilbagegange i alt, som den kode allerede understøtter; OCP indeslutter ny adfærd i nye, isolerede enheder.

Det er princippet bag udvidelige frameworks og plugin-systemer — og det afhænger af LSP, da substituérbare undertyper er det, der gør den "lukkede" kerne sikker at lade være uberørt.