Jelaskan Prinsip Terbuka/Tertutup secara mendalam.

Question

Accepted Answer

**Prinsip Terbuka/Tertutup (Open/Closed Principle, OCP)** menyatakan bahwa entitas software seharusnya **terbuka untuk perluasan tetapi tertutup untuk modifikasi**: Anda harus menambah perilaku baru dengan menambahkan kode baru, bukan dengan mengedit kode yang sudah ada dan teruji.

## Mengapa ini penting

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

Setiap tipe baru memaksa perubahan pada rantai `if/elif` yang terus bertambah — rapuh dan magnet untuk bug.

## OCP melalui polimorfisme

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

Menambahkan `Triangle` memerlukan **nol pengedit** pada `total_area` — perluasan tanpa modifikasi.

## Mekanisme yang memungkinkan OCP

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

## Jebakan

OCP yang dilakukan secara spekulatif menjadi over-engineering — abstraksi yang dibangun untuk variasi yang tidak pernah tiba. Terapkan di mana perubahan *mungkin* ("aturan tiga": abstrak setelah variasi benar-benar muncul).

## Mengapa ini penting

Mengedit kode yang teruji dalam pertempuran untuk menambah fitur berisiko regresi di semua hal yang kode itu sudah dukung; OCP membatasi perilaku baru ke unit baru yang terisolasi.

Ini adalah prinsip di balik framework yang dapat diperluas dan sistem plugin — dan bergantung pada LSP, karena subtipe yang dapat diganti adalah apa yang membuat inti "tertutup" aman untuk dibiarkan tanpa sentuhan.