Come funzionano l'ereditarietà, le classi astratte e le interfacce?

Question

Accepted Answer

PHP supporta l'ereditarietà OOP e l'astrazione attraverso tre meccanismi correlati: **ereditarietà di classe** (`extends`), **classi astratte** (classi base parziali), e **interfacce** (contratti). Ciascuno serve uno scopo di design diverso.

## Ereditarietà — estendi una classe parent

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

Una sottoclasse `extends` un parent, ereditando e opzionalmente sovrascrivendo i suoi membri. `parent::` chiama il metodo parent sovrascritto. PHP supporta **ereditarietà singola** (un solo parent).

## Classi astratte — una base parziale (non può essere istanziata)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

Una **classe astratta** mescola metodi astratti (le sottoclassi devono implementare) con codice concreto condiviso — una base che non può essere istanziata direttamente.

## Interfacce — contratti puri (multiple consentite)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

Un'**interfaccia** definisce un contratto (firme di metodi, nessuna implementazione). Una classe può `implement` **molte** interfacce — il modo di PHP per aggirare l'ereditarietà singola per condividere capacità.

## Quando usare quale

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Perché è importante

L'ereditarietà, le classi astratte e le interfacce sono strumenti OOP fondamentali, e comprendere le distinzioni è importante per progettare applicazioni PHP ben strutturate (e per lavorare con framework, che si basano pesantemente su questi). **L'ereditarietà** (`extends`) fornisce riutilizzo del codice tramite relazioni "is-a", ma PHP consente solo l'ereditarietà singola. **Le classi astratte** forniscono una base condivisa con codice implementato sia con metodi che le sottoclassi devono definire — buone per classi strettamente correlate che condividono logica. **Le interfacce** definiscono contratti/capacità, e crucialmente una classe può implementare **molte** di esse — rendendo le interfacce la chiave per design flessibili e disaccoppiati e la risposta di PHP al limite dell'ereditarietà singola.

Sapere quando usare ciascuna (ereditarietà per il riutilizzo is-a, classi astratte per l'implementazione parziale condivisa, interfacce per contratti/capacità), e il principio di **programming to interfaces** (dipendere da astrazioni per codice testabile, flessibile e framework-friendly), è conoscenza importante per il design OOP in PHP.

Questi meccanismi sono alla base di come framework come Laravel e Symfony strutturano il loro codice (interfacce e classi base astratte ovunque), rendendoli essenziali sia per progettare bene il tuo codice che per comprendere i framework su cui costruisci.