რა განსხვავებაა ინტერფეისისა და აბსტრაქტული კლასის შორის?

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-ს პასუხი მრავალი მემკვიდრეობაზე) — ოპტიმალური პერიფერული შესაძლებლობებისთვის.

აბსტრაქტული კლასები უზრუნველყოფენ **საზიარო ბაზას მდგომარეობითა და ნაწილობრივი განხორციელებით** მჭიდროდ დაკავშირებული ქვეკლასებისთვის, მაგრამ შეზღუდავენ მხოლოდ ერთი მემკვიდრეობით.

ტრეიდ-ოფის გაგება (მრავალი განხორციელება vs საზიარო მდგომარეობა/კონსტრუქტორები, შესაძლებლობა vs "არის" ურთიერთობა) სახელმძღვანელო კარგი API და კლასის იერარქიის დიზაინისთვის.

Java 8+ დეფოლტის მეთოდებით სასაზღვრო გაურკვევლობაა, იცოდეთ როდის არის თითოეული შესაფერი — და ძირითადი შეზღუდვები (ერთი აბსტრაქტული კლასი მაგრამ მრავალი ინტერფეისი, მდგომარეობა მხოლოდ აბსტრაქტული კლასებში) — აუცილებელი მოქნილი, კარგად სტრუქტურირებული კოდის დიზაინისთვის.