Composition — has-a relationship vs is-a — Hinglish notes

2.1.15 · Coding › OOP Fundamentals

Composition KYA hai?

Roz ka test:

Sentence jo natural lagta hai	Relationship	Tool
"A car is an engine" ❌	bakwaas	—
"A car has an engine" ✅	has-a	composition
"A dog is an animal" ✅	is-a	inheritance
"A dog has an animal" ❌	bakwaas	—

Composition ko prefer kyun karein? (famous principle)

Composition concretely kyun jeet ta hai:

Flexibility — tum part ko runtime pe swap kar sakte ho (car.engine = ElectricEngine()).
No combinatorial explosion — ek FlyingSwimmingRobot ko ek alag class ki zaroorat nahi; use ek Flyer part aur ek Swimmer part do.
Encapsulation — part ke guts hidden rehte hain.

Scratch se derive karna: "Car has-a Engine" banana

Hum structure ko memorize karne ki bajay derive karte hain.

Step 1 — responsibilities ko naam do. Ek car ko start() karna hoga. Starting ke liye ignition logic chahiye. Kyun split karein? Kyunki ignition ek self-contained concept hai jo independently change ho sakta hai (petrol vs electric).

Step 2 — sub-responsibility ko uski apni class do.

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower
    def ignite(self):
        return f"Engine roaring at {self.horsepower}hp"

Yeh step kyun? Hum volatile part ko isolate karte hain taki Car kabhi uske internals ko na chhuye.

Step 3 — Car ek Engine HOLD karta hai (composition) aur delegate karta hai.

class Car:
    def __init__(self, engine):          # engine passed IN
        self.engine = engine             # the has-a field
    def start(self):
        return "Car: " + self.engine.ignite()   # delegation

Kyun pass in karo (dependency injection)? Taki hum koi bhi engine de sakein — petrol, electric, mock — Car ko edit kiye bina.

Step 4 — use karo.

c = Car(Engine(120))
print(c.start())     # Car: Engine roaring at 120hp
c.engine = Engine(300)   # swap at runtime — inheritance ke saath impossible!

Figure — Composition — has-a relationship vs is-a

Worked examples

Worked example Example 1 — Ek bure "is-a" ko refactor karo

Galat design jo tempting lagti hai: class Stack(list) — "a stack is a list".

class Stack(list):
    def push(self, x): self.append(x)

Problem: ek Stack ab insert(), [i]=, slicing inherit kar leta hai — tum stack ke middle ko poke kar sakte ho, LIFO todke. Is-a claim bahut strong hai.

Has-a se fix karo: ek stack ke paas ek list hoti hai jo woh internally use karta hai.

class Stack:
    def __init__(self):
        self._items = []            # has-a list
    def push(self, x): self._items.append(x)
    def pop(self):    return self._items.pop()
    def size(self):   return len(self._items)

Kyun better hai? Sirf push/pop/size public hain — LIFO violate nahi ho sakta. Step kyun: _items ko hide karna dangerous extra methods hata deta hai.

Worked example Example 2 — Composition se class explosion bachti hai

Tumhe robots chahiye: kuch fly karte hain, kuch swim karte hain, kuch dono karte hain. Inheritance se tumhe FlyingRobot, SwimmingRobot, FlyingSwimmingRobot... (2^n classes) banane padte.

class Flyer:    def move(self): return "flying"
class Swimmer:  def move(self): return "swimming"
 
class Robot:
    def __init__(self, abilities):      # has-a list of abilities
        self.abilities = abilities
    def act(self):
        return [a.move() for a in self.abilities]
 
amphibot = Robot([Flyer(), Swimmer()])
print(amphibot.act())   # ['flying', 'swimming']

Yeh step kyun? Behaviors parts ban jaate hain jo tum runtime pe mix karte ho, na woh classes jo tum compile time pe banate ho.

Worked example Example 3 — Jab is-a SAHI hai

class Shape:
    def area(self): raise NotImplementedError
class Circle(Shape):           # a circle genuinely IS a shape
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r**2

Yahan inheritance kyun? Jahan bhi code Shape.area() expect kare, ek Circle perfectly kaam karta hai — substitutability hold karta hai. Is-a claim sach hai, toh inheritance theek hai.

Common mistakes (Steel-manned)

Recall Feynman: ek 12-saal ke bacche ko samjhao

LEGO imagine karo. Inheritance aise hai jaise kehna "ek race-car ek special kind of car hai" — wahi toy hai, bas fancy. Composition aise hai jaise car ko alag LEGO pieces se banana: wheels, ek engine block, ek seat. Agar engine pasand nahi, tum use pop off karo aur naya click in karo — poori car rebuild nahi karni. Yahi pop-and-swap hai jis wajah se builders composition love karte hain: car sirf ek engine rakhti hai, woh ek ban nahi jaati.

Flashcards

Composition kaunsi relationship model karta hai?

"has-a" — ek class doosri class ko field ke roop mein hold karta hai aur usse delegate karta hai.

Inheritance kaunsi relationship model karta hai?

"is-a" — subclass superclass ka ek type hota hai aur uski jagah substitute hone ke kaam aana chahiye.

Is-a vs has-a ka English test kya hai?

"A is a B" vs "A has a B" zyaar se padho; jo grammatically sach lage woh chuno.

"Favor composition over inheritance" kyun advise kiya jaata hai?

Composition ek choti public interface ke through loosely couple karta hai; inheritance parent ke internals se tightly couple karta hai aur parent changes pe break ho jaata hai (fragile base class).

class Stack(list) ek bura is-a design kyun hai?

Yeh list ka pura interface (insert, indexing, slicing) inherit kar leta hai, users ko LIFO violate karne deta hai. Has-a + ek hidden list use karo.

Composition combinatorial class explosion se kaise bachata hai?

Behaviors swappable part-objects ban jaate hain jo runtime pe mix hote hain, toh har combination ke liye alag class nahi chahiye.

Delegation kya hai?

Ek method kaam ko ek held object ko forward karta hai, jaise Car.start() self.engine.ignite() call karta hai.

Inheritance ko kaunsa deep type rule satisfy karna chahiye?

Liskov substitution — ek subclass ko jahan bhi superclass expect ho wahan kaam karna chahiye.

Runtime advantage jo sirf composition mein hai?

Tum held part ko program run hote waqt swap kar sakte ho (car.engine = ElectricEngine()); inheritance compile time pe fixed hoti hai.

Connections

Inheritance — is-a relationship
Liskov Substitution Principle
Encapsulation and Information Hiding
Dependency Injection
Strategy Pattern (composition of swappable behaviors)
Aggregation vs Composition (UML)
Fragile Base Class Problem