Method overriding — when and why — Hinglish notes

2.1.11 · Coding › OOP Fundamentals

WHAT it is

Teen look-alikes ka comparison (in confusions ko early steel-man karo):

Concept	Same name?	Same params?	Resolved kab?
Overriding	yes	yes (same signature)	runtime (object type)
Overloading	yes	different params	compile time (arg types)
Shadowing/hiding	yes (fields/static)	—	compile time (declared type)

WHY it exists

Intuition

Overriding isliye exist karta hai taaki if/else ladders khatam ho sakein. Iske bina tumhe likhna padta:

if shape is circle: area = pi*r*r
elif shape is rectangle: area = w*h
...  # every new shape edits this block

Overriding ke saath, har class apna behavior khud own karti hai. Ek naya shape add karna = ek nayi class add karna, existing code edit karna nahi. Yahi hai Open/Closed Principle: extension ke liye open, modification ke liye closed.

Teen reasons kyun hum override karte hain:

Specialize — child kaam ko apne hisaab se karta hai (Circle.area).
Extend — child extra karta hai plus parent ka kaam bhi (pehle super() call karo, phir add karo).
Fulfill a contract — ek abstract/base method zaroor children dwara implement honi chahiye.

HOW it works — dynamic dispatch ko scratch se derive karo

Hum "magically" sahi method nahi paate. Chalte hain mechanism build karte hain.

Har class ek hidden method table maintain karti hai (ek "vtable"): method name → code address ka map.

vtable (C) = {m \mapsto most-derived definition of m visible in C}

Shape ki table: area → Shape.area (shayad abstract/empty).
Circle ki table Shape ki table ki copy se shuru hoti hai, phir area → Circle.area ko overwrite karti hai.

Jab tum obj.area() call karte ho:

obj ki actual class dekho (object ke andar stored hoti hai).
Us class ki vtable par jao.
Jahan bhi area point karta hai, wahan jump karo.

Kyun yeh sahi behavior deta hai: kyunki object apna khud ka class pointer carry karta hai, chahe woh Shape-typed variable mein hold ho, step 1 Circle dhundh leta hai, isliye step 2 Circle.area dhundh leta hai. Declared type calculation mein kabhi aata hi nahi.

Figure — Method overriding — when and why

Worked examples

Worked example

1 — Basic specialization (Python)

class Shape:
    def area(self):                 # base "promise"
        raise NotImplementedError
 
class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self):                 # OVERRIDE
        return 3.14159 * self.r ** 2
 
class Rectangle(Shape):
    def __init__(self, w, h): self.w, self.h = w, h
    def area(self):                 # OVERRIDE
        return self.w * self.h
 
shapes = [Circle(2), Rectangle(3, 4)]
for s in shapes:
    print(s.area())     # 12.566..., 12

Yeh step kyun? s loosely ek Shape element ki tarah typed hai, lekin har s.area() real object par dispatch karta hai → har baar sahi formula. Koi if/else nahi.

Worked example

2 — super() ke saath extend karna

class Account:
    def describe(self):
        return "Account"
 
class SavingsAccount(Account):
    def describe(self):
        base = super().describe()      # reuse parent work
        return base + " (Savings, 4% interest)"
 
print(SavingsAccount().describe())     # Account (Savings, 4% interest)

Yeh step kyun? Hum parent ka text duplicate nahi karte. super().describe() parent body run karta hai, phir hum usme add karte hain. Override = "extend", "throw away" nahi.

Worked example

3 — Overriding vs overloading (Java-style, contrast dikhane ke liye)

class Printer {
    void print(String s) { ... }
    void print(int n)    { ... }      // OVERLOAD (different params)
}
class FancyPrinter extends Printer {
    @Override
    void print(String s) { ... }      // OVERRIDE (same signature)
}

Yeh step kyun? Printer mein do print = overloading, compile time par argument type se pick hota hai. FancyPrinter.print(String) = overriding, runtime par object type se pick hota hai. Ek hi word, bilkul alag mechanism.

Common mistakes (Steel-man + fix)

The 80/20 of this topic

Recall Feynman: ek 12-saal ke bacche ko explain karo

Ek Toy jaanta hai sound() kaise banate hain. Ek Dog toy aur ek Cat toy dono toys hain, lekin dog kehta hai "Woof" aur cat kehti hai "Meow". Jab tum kisi bhi toy se uski awaaz nikaalne ko kaho, har toy pehle se jaanta hai apna tarika — tumhe yaad rakhne ki zarurat nahi ki woh kaunsi type ka hai. Method overriding bas har cheez ko allow karta hai ki woh ek hi sawaal ka apne sahi tarike se jawab de, automatically.

Active-recall flashcards

Method overriding kya hai?

Ek subclass apni khud ki implementation deta hai ek aisi method ki jo already uske superclass mein defined hai, same name, parameters, aur compatible return type use karke.

Overriding vs overloading — kya differ karta hai?

Overriding = same signature, runtime par object type se resolve hota hai. Overloading = different parameters, compile time par argument types se resolve hota hai.

KAUNSA type decide karta hai ki kaunsa overridden method run hoga?

Object ka runtime (actual) type, variable ka declared/static type nahi — yahi dynamic dispatch hai.

Overriding mein vtable ka kya role hai?

Ek per-class table jo method name → code address map karti hai; child parent ki table copy karta hai phir overridden entries overwrite karta hai, taaki dispatch child ka version dhundh sake.

Overriding Open/Closed Principle ko kyun support karta hai?

Naya behavior ek naya subclass likh kar add hota hai (extension), existing type-checking if/else code edit karne ke bajaye (modification).

Kya tum overriding mein access narrow kar sakte ho?

Nahi — tum access widen kar sakte ho aur ek subtype return kar sakte ho (covariant return), lekin access narrow karna ya broader checked exceptions add karna substitutability (Liskov) todta hai.

Kya static methods override hote hain?

Nahi — woh hide hote hain (compile time par declared type se resolve hote hain); sirf instance methods override hote hain.

Override mein super() kya karta hai?

Parent ka method ka version call karta hai, child ko fully replace karne ki bajaye behavior extend karne deta hai.

Connections

Inheritance — overriding sirf ek inheritance chain ke along hota hai.
Polymorphism — overriding runtime polymorphism ka engine hai.
Method overloading — compile-time look-alike, contrast ke liye.
Abstract classes and interfaces — methods jo zaroor override hone chahiye.
Liskov Substitution Principle — woh rule jo overrides ko respect karna chahiye.
Open-Closed Principle — overriding ka design payoff.
super keyword — parent ke behavior ko extend karna.