ઈન્ટરફેસ અને એબ્સ્ટ્રેક્ટ ક્લાસ વચ્ચે શું તફાવત છે?

Question

Accepted Answer

બંને એબ્સ્ટ્રેક્ટ પ્રકારો વ્યાખ્યાયિત કરે છે જે સીધી રીતે ઇનસ્ટેન્શિएટ કરી શકાતા નથી અને તેઓ લાગુ કરવા/વિસ્તૃત કરવા માટે હોય છે — પરંતુ તેઓ વિવિધ ડિઝાઇન હેતુઓ પૂરી કરે છે. મુખ્ય તફાવતો **બહુવિધ વારસો**, **સ્થિતિ**, અને તેઓ જે સંબંધ મોડેલ કરે છે તે છે।

## ઈન્ટરફેસ — એક કરાર ("કર-શકો" / ક્ષમતા)

```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 */ }
}
```

ઈન્ટરફેસ વર્તનનું **કરાર** વ્યાખ્યાયિત કરે છે। ક્લાસ **બહુવિધ** ઈન્ટરફેસને લાગુ કરી શકે છે — આ રીતે Java બહુવિધ વારસાનું એક સ્વરૂપ પ્રાપ્ત કરે છે। ઈન્ટરફેસ (પરંપરાગતરીતે) કોઈ ઈનસ્ટેન્સ સ્થિતિ ધરાવતા નથી।

## એબ્સ્ટ્રેક્ટ ક્લાસ — આંશિક આધાર ("છે-" સાથે શેર કરેલ કોડ)

```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"); }
}
```

એબ્સ્ટ્રેક્ટ ક્લાસ **સ્થિતિ (ફીલ્ડ્સ)**, **કન્સ્ટ્રક્ટર્સ**, અને શેર કરેલ અમલીકરણ સાથે કોંક્રીટ પદ્ધતિઓ ધરાવી શકે છે — પરંતુ ક્લાસ માત્ર **એક** એબ્સ્ટ્રેક્ટ ક્લાસને વિસ્તૃત કરી શકે છે (એક જ વારસો)।

## મુખ્ય તફાવતો

```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)
```

## તે શા માટે મહત્વવાળું છે

ઈન્ટરફેસ અને એબ્સ્ટ્રેક્ટ ક્લાસ વચ્ચે પસંદ કરવી એક મૌલિક Java ડિઝાઇન નિર્ણય છે।

ઈન્ટરફેસ **કરાર/ક્ષમતાઓ** વ્યાખ્યાયિત કરે છે અને ક્લાસને તેમાંથી ઘણી બધી ક્રિયાઓ કરવા સક્ષમ બનાવે છે (બહુવિધ વારસા માટે Java નો જવાબ) — ક્રસ-કટિંગ ક્ષમતાઓ માટે આદર્શ।

એબ્સ્ટ્રેક્ટ ક્લાસ **શેર કરેલ આધાર સ્થિતિ અને આંશિક અમલીકરણ** સાથે ગાઢ સંબંધિત સબક્લાસ માટે પ્રદાન કરે છે, પરંતુ તમને એક જ વારસો સુધી મર્યાદિત કરે છે।

ट્રેડ-ઑફને સમજવું (બહુવિધ-અમલીકરણ વિ શેર કરેલ-સ્થિતિ/કન્સ્ટ્રક્ટર્સ, ક્ષમતા વિ છે-સંબંધ) સારી API અને ક્લાસ-હાયરાર્કી ડિઝાઇન માર્ગદર્શન આપે છે।

Java 8+ ડિફૉલ્ટ પદ્ધતિઓ સાથે લાઇનને ઝાપટી આપીને, જ્યારે દરેક બંધબેસે છે તે જાણવું — અને મુખ્ય અવરોધ (એક એબ્સ્ટ્રેક્ટ ક્લાસ પરંતુ ઘણા ઈન્ટરફેસ, એબ્સ્ટ્રેક્ટ ક્લાસમાં જ સ્થિતિ) — લવચીક, સારી રચના કરેલ કોડ ડિઝાઇન કરવા માટે આવશ્યક છે।