Qual è la differenza tra un'interfaccia e una classe astratta?

Question

Accepted Answer

Entrambe definiscono tipi astratti che non possono essere istanziati direttamente e sono pensati per essere implementati/estesi — ma servono a scopi di design diversi. Le distinzioni chiave sono **l'eredità multipla**, **lo stato**, e la relazione che modellano.

## Interfaccia — un contratto ("può-fare" / capacità)

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

Un'interfaccia definisce un **contratto** di comportamento. Una classe può implementare **multiple** interfacce — è così che Java raggiunge una forma di eredità multipla. Le interfacce (tradizionalmente) non hanno stato di istanza.

## Classe astratta — una base parziale ("è-un" con codice condiviso)

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

Una classe astratta può contenere **stato (campi)**, **costruttori**, e metodi concreti con implementazione condivisa — ma una classe può estendere solo **una** classe astratta (eredità singola).

## Differenze chiave

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

## Quando usare quale

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

## Perché è importante

Scegliere tra un'interfaccia e una classe astratta è una decisione di design fondamentale in Java.

Le interfacce definiscono **contratti/capacità** e consentono a una classe di implementarne molti (la risposta di Java all'eredità multipla) — ideali per capacità trasversali.

Le classi astratte forniscono una **base condivisa con stato e implementazione parziale** per sottoclassi strettamente correlate, ma ti limitano a un'eredità singola.

Comprendere i compromessi (implementazione multipla vs stato condiviso/costruttori, capacità vs relazione è-un) guida un buon design di API e gerarchie di classi.

Con Java 8+ e i metodi default che offuscano il confine, sapere quando ciascuno si adatta — e i vincoli fondamentali (una classe astratta ma molte interfacce, stato solo nelle classi astratte) — è essenziale per progettare codice flessibile e ben strutturato.