Interface vs Abstract Class

Contract vs Partial House

💡 Interface एक 100% contract है — सिर्फ़ rules, कोई काम पहले से नहीं किया गया। Abstract class एक अधूरा (half-built) घर है — कुछ काम already हो चुका, बाक़ी तुम्हे करना है।

Interface में (Java 8 से पहले) सिर्फ़ method signatures होते थे, कोई body नहीं — implementing class को सब लिखना पड़ता था।

Abstract class में कुछ methods complete हो सकते हैं और कुछ abstract (incomplete) — और एक class सिर्फ़ एक abstract class extend कर सकती है, पर कई interfaces implement कर सकती है।

interface Flyable { void fly(); }

abstract class Bird {
  void breathe() { System.out.println("breathing"); }
  abstract void fly();
}

📜

Interface एक 100% contract है — सिर्फ़ rules, कोई काम पहले से नहीं किया गया। Abstract class एक अधूरा (half-built) घर है — कुछ काम already हो चुका, बाक़ी तुम्हे करना है।

1 / 4

इस page में (5 subtopics)

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

← पिछला🚗 Abstraction अगला →🥅 Exception Handling

Code10x

Interface vs Abstract Class

Multiple Interface Implementation

default aur static Methods (Java 8+)

Functional Interfaces

Marker Interfaces

Interface vs Abstract Class — Complete Comparison