interface और abstract class में क्या अंतर है?

Question

Accepted Answer

दोनों abstract types परिभाषित करते हैं जिन्हें सीधे instantiate नहीं किया जा सकता और जिन्हें implement/extend किया जाना होता है — लेकिन वे अलग-अलग design उद्देश्यों की पूर्ति करते हैं। मुख्य अंतर हैं **multiple inheritance**, **state**, और वह संबंध जिसे वे model करते हैं।

## Interface — एक contract ("can-do" / capability)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

एक interface behavior का एक **contract** परिभाषित करता है। एक class **कई** interfaces को implement कर सकती है — इसी तरह Java multiple inheritance का एक रूप प्राप्त करता है। Interfaces (पारंपरिक रूप से) में कोई instance state नहीं होती।

## Abstract class — एक partial base (साझा code के साथ "is-a")

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

एक abstract class **state (fields)**, **constructors**, और साझा implementation वाली concrete methods रख सकती है — लेकिन एक class केवल **एक** abstract class को extend कर सकती है (single inheritance)।

## मुख्य अंतर

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## कब किसका उपयोग करें

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## यह क्यों महत्वपूर्ण है

interface और abstract class के बीच चुनाव एक मूलभूत Java design निर्णय है।

Interfaces **contracts/capabilities** परिभाषित करते हैं और एक class को उनमें से कई को implement करने में सक्षम बनाते हैं (multiple inheritance के लिए Java का उत्तर) — cross-cutting क्षमताओं के लिए आदर्श।

Abstract classes निकट से संबंधित subclasses के लिए **state और partial implementation के साथ एक साझा base** प्रदान करती हैं, लेकिन आपको single inheritance तक सीमित करती हैं।

trade-offs को समझना (multiple-implementation बनाम shared-state/constructors, capability बनाम is-a संबंध) अच्छे API और class-hierarchy design का मार्गदर्शन करता है।

Java 8+ की default methods के साथ यह रेखा धुंधली होने के कारण, यह जानना कि प्रत्येक कब उपयुक्त है — और मुख्य बाधाएं (एक abstract class लेकिन कई interfaces, state केवल abstract classes में) — लचीले, सुव्यवस्थित code को design करने के लिए आवश्यक है।