inheritance के बजाय अक्सर composition को क्यों प्राथमिकता दी जाती है?

Question

Accepted Answer

**Composition over inheritance** एक व्यापक रूप से उद्धृत design principle है — objects को base classes से inherit करने (inheritance) के बजाय **behaviors को combine करके** (composition) बनाने को प्राथमिकता देना। Inheritance के महत्वपूर्ण नुकसान हैं जिन्हें composition टालता है, हालाँकि दोनों की अपनी जगह है।

## inheritance बनाम composition

```text
INHERITANCE → a class EXTENDS another, inheriting its behavior ("IS-A" relationship):
  class Dog extends Animal
COMPOSITION → a class is BUILT FROM other objects/behaviors ("HAS-A" / uses):
  class Car { constructor() { this.engine = new Engine(); } }   // composes behaviors
→ composition: combine smaller pieces; inheritance: derive from a parent
```

## inheritance में समस्याएँ क्यों हैं

```text
✗ TIGHT COUPLING → subclasses are tightly bound to their parent's implementation (changes
  to the parent can break subclasses — the "fragile base class" problem)
✗ RIGID hierarchies → deep/wide inheritance trees become hard to change and understand
✗ Inflexible → a class can usually only inherit from ONE parent; behavior is fixed at compile
  time; hard to combine behaviors from multiple sources
✗ Forces an "IS-A" relationship that may not truly hold; exposes parent internals
```

## composition अक्सर बेहतर क्यों है

```text
✓ FLEXIBLE → compose behaviors as needed; combine multiple behaviors; change at RUNTIME
✓ LOOSE COUPLING → objects depend on interfaces of composed parts, not parent implementations
✓ REUSABLE → small, focused components reused in many combinations
✓ Easier to change/test; avoids fragile hierarchies; favors small, focused pieces
→ many patterns (Strategy, Decorator) use composition; "favor composition over inheritance"
  ⚠️ inheritance still has valid uses (true IS-A, sharing interface) → use it appropriately
```

## यह क्यों महत्वपूर्ण है

inheritance के बजाय अक्सर composition को क्यों प्राथमिकता दी जाती है यह समझना मूल्यवान senior-level ज्ञान है क्योंकि यह एक **मूलभूत design principle** है जो flexibility और maintainability को बेहतर बनाता है, परिपक्व design judgment को दर्शाता है।

"favor composition over inheritance" principle व्यापक रूप से उद्धृत किया जाता है क्योंकि inheritance, एक मूल OO feature होने के बावजूद, महत्वपूर्ण नुकसान रखता है।

**अंतर** को समझना (inheritance एक "IS-A" relationship के रूप में जो parent को extend करता है, composition एक "HAS-A" relationship के रूप में जो अन्य objects से बनता है) नींव है।

**inheritance में समस्याएँ क्यों हैं** यह समझना अहम अंतर्दृष्टि है: **tight coupling** (subclasses का parent के implementation से बँधना, जिसमें parent के बदलाव subclasses को तोड़ देते हैं — fragile base class समस्या), **rigid hierarchies** (deep inheritance trees का बदलना और समझना कठिन होना), **inflexibility** (आम तौर पर केवल single inheritance, compile time पर तय behavior, कई sources से behaviors combine करना कठिन), और ऐसे IS-A relationships को थोपना जो वास्तव में सच न हों।

ये वास्तविक, महत्वपूर्ण समस्याएँ हैं जो maintenance कठिनाइयाँ पैदा करती हैं।

**composition अक्सर बेहतर क्यों है** यह समझना — **flexibility** (ज़रूरत के अनुसार behaviors को compose और combine करना, runtime पर बदलना), **loose coupling** (parent implementations के बजाय composed parts के interfaces पर निर्भरता), **reusability** (small, focused components कई combinations में पुनः उपयोग), और आसान बदलाव तथा testing — समझाता है कि composition inheritance के नुकसानों को कैसे टालता है।

यह पहचानना कि कई patterns (Strategy, Decorator) composition का इस्तेमाल करते हैं, जबकि inheritance के अभी भी valid उपयोग हैं (वास्तविक IS-A relationships, interfaces साझा करना), संतुलित judgment को दर्शाता है — composition को *अक्सर* प्राथमिकता दी जाती है, लेकिन inheritance की अपनी जगह है।

यह principle flexible, maintainable design के लिए मूलभूत है।

चूँकि "favor composition over inheritance" एक मूलभूत, व्यापक रूप से उद्धृत design principle है, और चूँकि inheritance के वास्तविक नुकसान (coupling, rigidity, inflexibility) और composition के फायदे (flexibility, loose coupling, reusability) को समझना — inheritance के valid उपयोगों को पहचानते हुए — परिपक्व design judgment को दर्शाता है जो code को बेहतर बनाता है, इसलिए inheritance के बजाय अक्सर composition को क्यों प्राथमिकता दी जाती है यह समझना मूल्यवान senior-level ज्ञान है — flexible, maintainable code के लिए एक मूलभूत design principle, कई patterns का आधार, और senior developers से अपेक्षित परिपक्व design judgment (composition को प्राथमिकता देते हुए inheritance की जगह को जानना) को दर्शाता है जो अच्छी तरह design किया गया object-oriented software लिखते हैं।