interface ਅਤੇ abstract class ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?

Question

Accepted Answer

ਦੋਨੋ abstract types ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ ਜੋ ਸਿੱਧੇ ਤੌਰ 'ਤੇ instantiate ਨਹੀਂ ਕੀਤੇ ਜਾ ਸਕਦੇ ਅਤੇ implement/extend ਕੀਤੇ ਜਾਣ ਦੇ ਲਈ ਹਨ — ਪਰ ਉਹ ਵੱਖ-ਵੱਖ ਡਿਜ਼ਾਈਨ ਉਦੇਸ਼ਾਂ ਦੀ ਪੂਰਤੀ ਕਰਦੇ ਹਨ। ਮੁੱਖ ਅੰਤਰ **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 ਵਿਵਹਾਰ ਦਾ ਇੱਕ **ਐਂਟਰੀਮੈਂਟ** ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਕਲਾਸ **ਕਈ** 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 ਦੇ ਨਾਲ ਰੱਖ ਸਕਦਾ ਹੈ — ਪਰ ਇੱਕ ਕਲਾਸ ਸਿਰਫ ਇੱਕ **ਇੱਕ** 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 ਡਿਜ਼ਾਈਨ ਫੈਸਲਾ ਹੈ।

Interfaces **ਐਂਟਰੀਮੈਂਟਸ/ਸਮਰੱਥਾਵਾਂ** ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ ਅਤੇ ਇੱਕ ਕਲਾਸ ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ ਕਈ ਨੂੰ implement ਕਰਨ ਲਈ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਨ (Java ਦਾ multiple inheritance ਦਾ ਜਵਾਬ) — cross-cutting ਸਮਰੱਥਾਵਾਂ ਲਈ ਆਦਰਸ਼।

Abstract classes ਇੱਕ **ਸਾਂਝੇ ਅਧਾਰ ਨੂੰ state ਅਤੇ ਆਂਸ਼ਿਕ implementation ਦੇ ਨਾਲ** ਸਪੱਸ਼ਟ ਰੂਪ ਨਾਲ ਸਬੰਧਿਤ subclasses ਲਈ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਪਰ ਤੁਹਾਨੂੰ single inheritance ਤੱਕ ਸੀਮਿਤ ਕਰਦੇ ਹਨ।

Trade-offs ਨੂੰ ਸਮਝਣਾ (multiple-implementation ਬਨਾਮ shared-state/constructors, capability ਬਨਾਮ is-a ਸਬੰਧ) ਚੰਗਾ API ਅਤੇ class-hierarchy ਡਿਜ਼ਾਈਨ ਦੀ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।

Java 8+ default methods ਦੇ ਨਾਲ ਲਾਈਨ ਧੁੰਦਲੀ ਹੋ ਰਹੀ ਹੈ, ਜਾਣਨਾ ਕਿ ਕਦੋਂ ਹਰੇਕ ਫਿੱਟ ਹੋਵੇ — ਅਤੇ ਮੁੱਖ ਪਾਬੰਦੀਆਂ (ਇੱਕ abstract class ਪਰ ਕਈ interfaces, state ਸਿਰਫ abstract classes ਵਿੱਚ) — ਲਚਕਦਾਰ, ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਗਠਿਤ ਕੋਡ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਲਾਜ਼ਮੀ ਹੈ।