Forklar Open/Closed Principle i dybden.

Question

IT Interview Practice · 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.

Den lugt OCP sigter mod

OCP via polymorfisme

Mekanismer, der muliggør OCP

Faldgruppe

Hvorfor det betyder noget

Relaterede spørgsmål