Open/Closed Principle பற்றி ஆழமாக விளக்குக.

Question

Accepted Answer

**Open/Closed Principle (OCP)** மென்பொருளின் உருவாக்கங்கள் **நீட்டிப்புக்குக் திறந்திருக்க வேண்டும் ஆனால் மாற்றத்திற்கு மூடப்பட்டிருக்க வேண்டும்** என்று கூறுகிறது: பழைய, சோதனைக்குட்பட்ட குறியீட்டை திருத்தாமல் புதிய குறியீட்டைச் சேர்த்து புதிய நடத்தைகளைச் சேர்க்க வேண்டும்.

## OCP குறிக்கும் வாசனை

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

பிரতியொரு புதிய வகையும் வளர்ந்த `if/elif` சங்கிலிக்கு மாற்றத்தைக் கட்டாயப்படுத்துகிறது — உடையக்கூடிய மற்றும் பிழைகளுக்கான ஆகர்ஷணம்.

## பன்முகப்படுத்தல் மூலம் OCP

```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` சேர்ப்பது `total_area` க்கு **பூஜ்ய மாற்றங்கள்** தேவை — மாற்றம் இல்லாத நீட்டிப்பு.

## OCP ஐ செயல்படுத்தும் பொறிமுறைகள்

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

## ஆபத்து

OCP அனுமানவாதமாக செய்யப்படுவது அதிகமாக பொறியியல் — எப்போதும் வராத மாறுபாட்டுக்காக கட்டப்பட்ட சுருக்கங்கள். இதைப் பயன்படுத்துங்கள் மாற்றம் *சாத்தியமாக* இருக்கும் இடங்களில் ("மூன்று விதி": மாறுபாடு உண்மையிலேயே தோன்றிய பிறகு சுருக்கம் செய்யுங்கள்).

## இது ஏன் முக்கியமானது

சிறப்பு சோதனைக்குட்பட்ட குறியீட்டை ஒரு அம்சத்தைச் சேர்க்க திருத்துவது அந்த குறியீட்டு ஏற்கனவே ஆதரிக்கும் அனைத்திலும் தராதல்களை ஆபத்தாக்குகிறது; OCP புதிய நடத்தைகளை புதிய, தனிமைப்படுத்தப்பட்ட அலகுகளுக்கு கட்டுப்படுத்துகிறது.

இது விரிவாக்கக்கூடிய கட்டமைப்புகள் மற்றும் plugin அமைப்புகளின் பின்னணியில் உள்ள கொள்கை — மற்றும் இது LSP ஐ சார்ந்துள்ளது, ஏனெனில் மாற்றிக்கூடிய உப-வகைகள் "மூடிய" மையத்தைத் தொடாமல் பாதுகாப்பாக வைத்திருப்பதாகும்.