Giải thích sâu về Open/Closed Principle.

Question

Accepted Answer

**Open/Closed Principle (OCP)** nói rằng các thực thể phần mềm nên **mở cho mở rộng nhưng đóng cho sửa đổi**: bạn nên thêm hành vi mới bằng cách thêm code mới, không phải bằng cách chỉnh sửa code đã có sẵn và đã được kiểm thử.

## "Mùi" mà OCP nhắm tới

```python
# ĐÓNG với mở rộng: mỗi shape mới chỉnh sửa method này (rủi ro, phải test lại mọi thứ)
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
    # thêm một triangle → lại sửa đổi hàm này...
```

Mỗi kiểu mới ép buộc một thay đổi vào chuỗi `if/elif` ngày càng phình ra — mong manh và là thỏi nam châm hút bug.

## OCP thông qua polymorphism

```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):                 # hành vi MỚI = class MỚI
    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):                # không bao giờ phải đổi nữa
    return sum(s.area() for s in shapes)
```

Thêm `Triangle` không cần **một chỉnh sửa nào** vào `total_area` — mở rộng mà không sửa đổi.

## Các cơ chế giúp OCP khả thi

```text
→ polymorphism / inheritance     → strategy pattern (inject hành vi)
→ plugin / interface             → higher-order function / callback
```

## Cạm bẫy

OCP làm theo kiểu đầu cơ trở thành over-engineering — các abstraction xây cho sự biến thiên không bao giờ đến. Hãy áp dụng nó ở nơi thay đổi *có khả năng* xảy ra ("quy tắc số ba": trừu tượng hóa sau khi sự biến thiên thực sự xuất hiện).

## Tại sao điều này quan trọng

Chỉnh sửa code đã được thử lửa để thêm một tính năng có nguy cơ gây hồi quy (regression) trong mọi thứ code đó đã hỗ trợ; OCP giới hạn hành vi mới vào các đơn vị mới, biệt lập.

Đó là nguyên tắc đứng sau các framework và hệ thống plugin có thể mở rộng — và nó phụ thuộc vào LSP, vì các subtype thay thế được mới là thứ khiến phần lõi "đóng" an toàn để giữ nguyên không động tới.