Interface మరియు abstract class మధ్య తేడా ఏమిటి?

Question

Accepted Answer

రెండూ నేరుగా ఇన్‌స్టాన్‌షియేట్ చేయలేని మరియు అమలు చేయవలసిన/విస్తరించవలసిన నైరూప్య రకాలను నిర్వచిస్తాయి — కానీ అవి విభిన్న డిజైన్ ఉద్దేశ్యాలను పూరిస్తాయి. ప్రధాన తేడాలు **బహుళ వారసత్వం**, **స్థితి** మరియు అవి నమూనా చేసే సంబంధం.

## Interface — ఒక ఒప్పంద ("చేయగలిగిన" / సామర్థ్యం)

```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 ను అమలు చేయవచ్చు — ఇది జావాకు బహుళ వారసత్వం రూపాన్ని సాధించేలా చేస్తుంది. Interfaces (సాంప్రదాయకంగా) ఏ ఉదాహరణ స్థితిని కలిగి ఉండవు.

## నైరూప్య తరగతి — ఒక పాక్షిక ఆధారం ("ఉమ్మడి కోడ్‌తో "ఎ-ఆ")

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

## ఇది ఎందుకు ముఖ్యమైనది

Interface మరియు నైరూప్య తరగతి మధ్య ఎంచుకోవడం మూల Java డిజైన్ నిర్ణయం.

Interfaces **ఒప్పందాలు/సామర్థ్యాలను** నిర్వచిస్తాయి మరియు ఒక తరగతిని వాటిలో చాలా ఉపయోగించేందుకు ఎనేబల్ చేస్తాయి (బహుళ వారసత్వానికి జావా యొక్క సమాధానం) — క్రాస్-కటింగ్ సామర్థ్యాలకు ఆదర్శవంతమైనది.

నైరూప్య తరగతులు దగ్గరగా సంబంధిత ఉపవర్గాల కోసం **ఉమ్మడి ఆధారం, స్థితి మరియు పాక్షిక అమలు** ను అందిస్తాయి, కానీ మీకు ఏక వారసత్వానికి పరిమితం చేస్తాయి.

ట్రేడ్-ఆఫ్‌లను అర్థం చేసుకోవడం (బహుళ-అమలు వర్సెస్ ఉమ్మడి-స్థితి/కన్‌స్ట్రక్టర్‌లు, సామర్థ్యం వర్సెస్ ఐఎ సంబంధం) మంచి API మరియు తరగతి-సోపానక్రమం డిజైన్‌ను నిర్దేశిస్తుంది.

జావా 8+ డిఫాల్ట్ పద్ధతులతో రేఖను సంపూర్ణ చేయడం, ప్రతిదీ ఎప్పుడు సరిపోతుందో తెలుసుకోవడం — మరియు కోర్ నిబంధనలు (ఒక నైరూప్య తరగతి కానీ చాలా interfaces, స్థితి నైరూప్య తరగతులలో మాత్రమే) — సరళ, బాగా-నిర్మిత కోడ్‌ను రూపకల్పన చేయడానికి ముఖ్యమైనది.