ஒரு interface மற்றும் abstract class இடையேயான வேறுபாடு என்ன?

Question

Accepted Answer

இரண்டும் abstract வகைகளை வரையறை செய்கின்றன, அவை நேரடியாக உதாரணப்படுத்த முடியாது மற்றும் செயல்படுத்த/விரிவுபடுத்த வேண்டும் — ஆனால் அவை வெவ்வேறு வடிவமைப்பு நோக்கங்களைக் கொண்டுள்ளன. முக்கிய வேறுபாடுகள் **பல வாரிசு**, **நிலை** மற்றும் அவை மாதிரியாக்கும் உறவு ஆகும்.

## 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 நடத்தையின் **ஒப்பந்தத்தை** வரையறை செய்கிறது. ஒரு வகுப்பு **பல** interface களை செயல்படுத்தலாம் — இது Java பல வாரிசு வடிவத்தை அடைய முடிய வைக்கிறது. Interface கள் (பாரம்பரியமாக) நிகழ் நிலைகளைக் கொண்டிருக்கவில்லை.

## Abstract class — ஒரு பகுதி அடிப்படை ("ஆகிய" பகிரப்பட்ட குறியீட்டுடன்)

```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 வகுப்பு **நிலை (புலங்கள்)**, **கன்ஸ்ட்ரக்டர்கள்** மற்றும் பகிரப்பட்ட செயல்பாட்டுடன் கான்கிரீட் முறைகளைக் கொண்டிருக்கலாம் — ஆனால் ஒரு வகுப்பு **ஒரு** abstract வகுப்பை மட்டுமே நீட்டிக்கலாம் (ஒற்றை வாரிசு).

## முக்கிய வேறுபாடுகள்

```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 வகுப்பிற்கு இடையே தேர்வு செய்வது Java வடிவமைப்பின் அடிப்படையான முடிவு.

Interface கள் **ஒப்பந்தங்கள்/திறன்களை** வரையறை செய்கின்றன மற்றும் ஒரு வகுப்பு அவற்றில் பலவற்றைச் செயல்படுத்த அனுமதிக்கின்றன (பல வாரிசுக்கான Java இன் பதில்) — குறுக்கு வெட்டு திறன்களுக்கு சிறந்தது.

Abstract வகுப்புகள் நிகடமாக தொடர்புடைய subclass களுக்கு **பகிரப்பட்ட அடிப்படை, நிலை மற்றும் பகுதி செயல்பாட்டை** வழங்குகின்றன, ஆனால் ஒற்றை வாரிசுக்கு உங்களை மட்டுப்படுத்துகின்றன.

வர்த்தனையின் பரிமாற்றங்களைப் புரிந்துகொள்ளுதல் (பல செயல்பாடு எதிர் பகிரப்பட்ட நிலை/கன்ஸ்ட்ரக்டர்கள், திறன் எதிர் ஆகிய உறவு) நல்ல API மற்றும் வகுப்பு-கற்பனை வடிவமைப்பை வழிகாட்டுகிறது.

Java 8+ இயல்புநிலை முறைகளுடன் கோடு மங்கலாக்குகிறது, ஒவ்வொன்று எப்போது பொருந்துகிறது என்று தெரிந்துகொள்ளுதல் — மற்றும் மைய கட்டுப்பாடுகள் (ஒரு abstract வகுப்பு ஆனால் பல interface கள், நிலை abstract வகுப்புகளிலுமே மட்டுமே) — நমনীய, நன்கு கட்டமைக்கப்பட்ட குறியீடு வடிவமைப்பதற்கு முக்கியமாகும்.