Inheritance
extends keyword se ek class dusri class ke fields aur methods use kar sakti hai, bina dobara likhe.
Ye code reuse badhata hai — common cheezein parent mein likho, specific cheezein child mein.
class Animal {
void eat() { System.out.println("Eating..."); }
}
class Dog extends Animal {
void bark() { System.out.println("Woof!"); }
}Single: ek class ek hi parent extend karti hai (Dog extends Animal) — sabse common type.
Multilevel: chain banti hai (Puppy extends Dog extends Animal) — Puppy ko Dog ke bhi features milte hain aur Animal ke bhi (transitively).
Hierarchical: ek parent ke multiple children hote hain (Dog aur Cat dono Animal extend karte hain) — dono ko Animal ka common behavior milta hai, lekin apna-apna specific behavior bhi.
Multiple inheritance (ek class do classes extend kare, jaise class C extends A, B) Java classes ke liye allowed NAHI hai — "diamond problem" se bachne ke liye (agar A aur B dono mein same-naam ka method ho, to C ko pata nahi chalega kaunsa use kare). Ye interfaces ke through partially achieve hota hai (ek class multiple interfaces implement kar sakti hai).
| Type | Example |
|---|---|
| Single | Dog extends Animal |
| Multilevel | Puppy extends Dog extends Animal |
| Hierarchical | Dog extends Animal, Cat extends Animal |
| Multiple (classes) | NOT allowed in Java |
super.method() se parent class ka overridden method call kar sakte ho (child ke andar se) — useful jab child parent ka behavior *extend* karna chahta hai, replace nahi. super.field se parent ka field access kar sakte ho agar child mein same naam ka field ho (variable "shadowing" ho rahi ho). super(...) parent constructor call karta hai.
class Dog extends Animal {
void makeSound() {
super.makeSound(); // pehle parent ka version chalao
System.out.println("Woof!"); // fir apna add karo
}
}Overriding ke liye method signature (naam + parameters, same order/types) exactly same hona chahiye parent aur child mein. Return type same ya "covariant" (subtype) ho sakta hai.
@Override annotation lagana best practice hai — compiler check kar leta hai ki tum sach mein override kar rahe ho (typo hone par compile error milega, jo silent bug se kahin better hai).
Access modifier child mein parent se zyada ya equal restrictive nahi ho sakta — public method ko protected nahi bana sakte overriding karte waqt (ye "visibility widen ho sakti hai, narrow nahi" wala rule hai).
Jab child class ka object banta hai, sabse pehle parent class ka constructor chalta hai (implicitly ya super() se explicitly), fir child ka constructor. Isse guarantee milti hai ki parent ka setup pehle complete ho, child usi ke upar build kare.
Ye chain root tak jaati hai — agar 3-level inheritance hai (A -> B -> C), to object banते waqt order hota hai: A ka constructor, phir B ka, phir C ka.