Interfacce e Classi Astratte in PHP: Qual è la Differenza?

Sia le interfacce che le classi astratte sono strumenti della programmazione a oggetti che permettono di definire una sorta di "contratto" o "modello" che altre classi devono seguire. Tuttavia, lo fanno in modi diversi e per scopi diversi.

Le Interfacce (Interfaces)

Un'interfaccia definisce quali metodi una classe deve implementare, ma non come. È un contratto puro al 100%. Specifica solo le firme dei metodi pubblici, senza alcun corpo (codice).

Una classe "implementa" un'interfaccia usando la parola chiave `implements`. Se una classe implementa un'interfaccia, è obbligata a definire tutti i metodi dichiarati nell'interfaccia, altrimenti PHP genererà un errore.

interface Pagabile {
    public function calcolaTotale();
    public function getMetodoPagamento();
}

class Ordine implements Pagabile {
    // Devo implementare entrambi i metodi, altrimenti errore.
    public function calcolaTotale() { /* ... */ }
    public function getMetodoPagamento() { /* ... */ }
}

Una classe può implementare più interfacce. Si usano per definire un comportamento ("cosa sa fare una cosa"), non un'identità.

Le Classi Astratte (Abstract Classes)

Una classe astratta è una "classe incompleta". È a metà strada tra un'interfaccia e una classe concreta. Può contenere sia metodi astratti (senza corpo, come un'interfaccia) che metodi concreti (con il loro codice).

Non puoi creare un'istanza di una classe astratta. Puoi solo estenderla con una classe figlia (usando `extends`), la quale sarà obbligata a implementare tutti i metodi astratti della madre.

abstract class Veicolo {
    // Metodo concreto, condiviso da tutti i figli
    public function accendi() {
        return "Motore acceso.";
    }

    // Metodo astratto, ogni figlio deve implementarlo a modo suo
    abstract public function getNumeroRuote();
}

class Auto extends Veicolo {
    public function getNumeroRuote() {
        return 4;
    }
}

Una classe può estendere una sola classe astratta. Si usano per definire un'identità e condividere del codice comune ("cos'è una cosa"), come abbiamo visto parlando di ereditarietà.

In Sintesi

• Usa un'interfaccia per definire un contratto di comportamento che classi diverse possono condividere (es. `Loggable`, `Cacheable`).
• Usa una classe astratta per creare una classe base che condivide del codice comune con le sue sottoclassi.