Selitä Open/Closed Principle syvällisesti.

Question

Accepted Answer

**Open/Closed Principle (OCP)** sanoo, että ohjelmistoentiteetin tulee olla **avoin laajennukselle mutta suljettu muutokselle**: sinun tulee lisätä uutta käyttäytymistä lisäämällä uutta koodia, ei muokkaamalla olemassa olevaa, testattua koodia.

## Hajanta, jota OCP kohdistaa

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

Jokainen uusi tyyppi pakottaa muutoksen kasvavaan `if/elif`-ketjuun — hauras ja virheiden magneetti.

## OCP polymorfismin kautta

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

`Triangle` lisääminen vaatii **nolla muokkausta** `total_area`:iin — laajennus ilman muutosta.

## Mekanismit, jotka mahdollistavat OCP:n

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

## Loukka

OCP tehtynä spekulatiivisesti tulee yliyrittyneiseksi — abstraktiot rakennettu vaihtelulle, joka ei koskaan tule. Käytä sitä, missä muutos on *todennäköinen* ("kolmen sääntö": abstrahoi sen jälkeen, kun vaihtelu todella ilmaantuu).

## Miksi se on tärkeää

Hyvin testatun koodin muokkaaminen ominaisuuden lisäämiseksi riskeillä regressioita kaikessa, mitä kyseinen koodi jo tukee; OCP rajoittaa uuden käyttäytymisen uusiin, eristettyihin yksiköihin.

Se on periaate laajennettavien kehysten ja plug-in-järjestelmien takana — ja se riippuu LSP:stä, koska korvattavat alityypit ovat se, mikä tekee "suljetusta" ytimestä turvallisen jättää koskemattomaksi.