Care este diferența dintre o interfață și o clasă abstractă?

Question

Accepted Answer

Ambele definesc tipuri abstracte care nu pot fi instanțiate direct și sunt destinate să fie implementate/extinse — dar servesc scopuri de design diferite. Distincțiile cheie sunt **moștenire multiplă**, **stare** și relația pe care o modelează.

## Interfață — un contract ("can-do" / capacitate)

```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 */ }
}
```

O interfață definește un **contract** de comportament. O clasă poate implementa **multiple** interfețe — aceasta este modul în care Java realizează o formă de moștenire multiplă. Interfețele (tradițional) nu au stare de instanță.

## Clasă abstractă — o bază parțială ("is-a" cu cod partajat)

```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"); }
}
```

O clasă abstractă poate conține **stare (câmpuri)**, **constructori** și metode concrete cu implementare partajată — dar o clasă poate extinde doar **o singură** clasă abstractă (moștenire simplă).

## Diferențe cheie

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

## Când să folosești care

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

## De ce conteaza

Alegereadintre o interfață și o clasă abstractă este o decizie fundamentală de design în Java.

Interfețele definesc **contracte/capacități** și permit unei clase să implementeze multe dintre ele (răspunsul Java la moștenire multiplă) — ideal pentru abilități transversale.

Clasele abstracte oferă o **bază partajată cu stare și implementare parțială** pentru subclase strâns legate, dar vă limitează la moștenire simplă.

Înțelegerea compromisurilor (implementare multiplă vs stare partajată/constructori, capacitate vs relație is-a) ghidează un bun design API și al ierarhiei claselor.

Cu metodele implicite din Java 8+ estompând linia, știind când fiecare se potrivește — și constrângerile principale (o clasă abstractă dar multe interfețe, stare doar în clase abstracte) — este esențial pentru a proiecta cod flexibil și bine structurat.