interface र abstract class बीचको फरक के हो?

Question

IT Interview Practice · Accepted Answer

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

## Interface — एक अनुबन्ध ("can-do" / क्षमता)

```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 ले **अनुबन्ध** व्यवहारको परिभाषा गर्छ। एक class ले **एकाधिक** interfaces implement गर्न सक्छ — यो Java ले multiple inheritance को रूप प्राप्त गर्ने तरीका हो। Interfaces (परम्परागत रूपमा) कुनै instance state राखदैनन्।

## Abstract class — एक आंशिक आधार ("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**, र concrete methods साझा implementation सहित राख्न सक्छ — तर एक class केवल **एक** abstract class (single inheritance) extend गर्न सक्छ।

## मुख्य भेदहरू

```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 ले **अनुबन्ध/क्षमताहरू** परिभाषित गर्छन् र एक class लाई धेरै implement गर्न सक्षम बनाउँछन् (Java को multiple inheritance को उत्तर) — क्रस-कटिंग क्षमताहरूका लागि आदर्श।

Abstract classes ले **state र आंशिक implementation सहित साझा आधार** प्रदान गर्छन् मिलिसक्ने subclasses को लागि, तर तपाईंलाई 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 मा) — लचकदार, राम्रो-संरचित कोड डिजाइन गर्न आवश्यक छ।

Interface — एक अनुबन्ध ("can-do" / क्षमता)

Abstract class — एक आंशिक आधार ("is-a" साझा कोड सहित)

मुख्य भेदहरू

कुन को प्रयोग कहिले गर्ने

यो किन महत्वपूर्ण छ

सम्बन्धित प्रश्नहरू