Interface vs Abstract Class
Interface mein (Java 8 se pehle) sirf method signatures hote the, koi body nahi — implementing class ko sab likhna padta tha.
Abstract class mein kuch methods complete ho sakte hain aur kuch abstract (incomplete) — aur ek class sirf ek abstract class extend kar sakti hai, par kayi interfaces implement kar sakti hai.
interface Flyable { void fly(); }
abstract class Bird {
void breathe() { System.out.println("breathing"); }
abstract void fly();
}Ek class multiple interfaces implement kar sakti hai (comma se separate karke) — ye Java mein "multiple inheritance of type" ka safe tareeka hai (classes ke saath jo allowed nahi wo interfaces ke saath allowed hai). Jaise ek class Flyable aur Swimmable dono implement kar sakti hai (jaise Duck class, jo dono kaam kar sakti hai).
interface Flyable { void fly(); }
interface Swimmable { void swim(); }
class Duck implements Flyable, Swimmable {
public void fly() { System.out.println("Flying"); }
public void swim() { System.out.println("Swimming"); }
}Java 8 se pehle interface mein sirf abstract methods hote the — 100% contract. Ab default methods (body ke saath) add kar sakte ho — existing interfaces ko naye methods se extend karna aasan hota hai bina saari implementing classes tode (jaise List interface mein sort() method Java 8 mein add hua, purani classes automatically kaam karti rahi).
static methods bhi ho sakte hain, jo interface ke naam se directly call hote hain (Interface.method()) — implementing class ke through nahi.
interface Vehicle {
void drive();
default void honk() { System.out.println("Beep!"); } // default body
}Ek interface jisme sirf ek hi abstract method ho use "Functional Interface" kehte hain (default/static methods count nahi hote isme). Ye Lambda expressions ke target type hote hain — Java 8+ ka core concept (Java 8+ topic mein poora detail hai).
@FunctionalInterface annotation optional hai lekin best practice — compiler check karta hai ki interface mein sach mein sirf ek abstract method hai, warna compile error deta hai (agar galti se doosra abstract method add ho jaaye).
Kuch interfaces bilkul khaali hote hain, koi method hi nahi — jaise Serializable, Cloneable. Ye sirf ek "marker/tag" ki tarah kaam karte hain, JVM ko batate hain ki is class ke objects ek special tareeke se treat karne hain (jaise Serializable objects ko byte stream mein convert kiya ja sakta hai, non-Serializable ko nahi).
Ye interviews ka sabse common comparison hai — dono ka purpose overlap karta hai lekin key differences hain jo decide karte hain kab kaunsa use karna hai.
| Criteria | Interface | Abstract Class |
|---|---|---|
| Methods | Abstract + default/static (Java 8+) | Abstract + concrete dono |
| Multiple inheritance | Class kayi implement kar sakti hai | Sirf ek extend kar sakti hai |
| Constructors | Nahi ho sakte | Ho sakte hain |
| Fields | Sirf public static final (constants) | Koi bhi type ke instance fields |
| Kab use karein | Unrelated classes mein common contract | Related classes mein shared code |