Interface vs Abstract Class

Contract vs Partial House

💡 An interface is a 100% contract — just rules, no work done yet. An abstract class is a half-built house — some work is already done, the rest is up to you.

Before Java 8, an interface had only method signatures, no body — the implementing class had to write everything.

An abstract class can have some complete methods and some abstract (incomplete) ones — and a class can extend only one abstract class, but implement many interfaces.

interface Flyable { void fly(); }

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

📜

An interface is a 100% contract — just rules, no work done yet. An abstract class is a half-built house — some work is already done, the rest is up to you.

1 / 4

On this 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

← Previous🚗 Abstraction Next →🥅 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