Il polimorfismo è un concetto fondamentale nella programmazione orientata agli oggetti (OOP) che permette agli oggetti di diversi tipi di essere trattati come se fossero dello stesso tipo, generalmente attraverso una classe base comune. In PHP, il polimorfismo si realizza principalmente attraverso l’uso di interfacce e classi astratte.
Le interfacce in PHP sono dichiarazioni di metodi che una classe deve implementare. Ecco un esempio di interfaccia:
```
interface Animale {
public function emettiSuono();
}
class Cane implements Animale {
public function emettiSuono() {
echo “Bau!”;
}
}
class Gatto implements Animale {
public function emettiSuono() {
echo “Miao!”;
}
}
function faiEmettereSuono(Animale $animale) {
$animale->emettiSuono();
}
$fido = new Cane();
$whiskers = new Gatto();
faiEmettereSuono($fido); // Output: Bau!
faiEmettereSuono($whiskers); // Output: Miao!
```
In questo esempio, l’interfaccia `Animale` dichiara un metodo `emettiSuono`. Le classi `Cane` e `Gatto` implementano questa interfaccia e offrono le loro specifiche implementazioni del metodo `emettiSuono`. La funzione `faiEmettereSuono` accetta un parametro di tipo `Animale` e può chiamare il metodo `emettiSuono` su qualsiasi oggetto che implementa l’interfaccia `Animale`.
Una classe astratta può fornire sia un’implementazione parziale che totale dei metodi e può anche richiedere alle classi derivate di implementare certi metodi. Ecco un esempio di classe astratta:
```
abstract class Forma {
abstract protected function area();
class Cerchio extends Forma { private $raggio;
public function __construct($r) { $this->raggio = $r; } public function area() { return pi() * $this->raggio * $this->raggio; } }class Rettangolo extends Forma { private $larghezza, $altezza;
public function __construct($l, $h) { $this->larghezza = $l; $this->altezza = $h; } public function area() { return $this->larghezza * $this->altezza; } }$cerchio = new Cerchio(5);
$rettangolo = new Rettangolo(4, 6);
echo $cerchio->area(); // Output: 78.539816339745
echo $rettangolo->area(); // Output: 24
```
In questo esempio, `Forma` è una classe astratta che definisce un metodo astratto `area` e un metodo concreto `descrivi`. Le classi `Cerchio` e `Rettangolo` estendono `Forma` e forniscono implementazioni specifiche del metodo `area`.
1. Codice più leggibile e manutenibile: Il polimorfismo permette di lavorare con le classi attraverso la loro interfaccia comune, riducendo le dipendenze e semplificando la modifica del codice.
2. Estensibilità: Aggiungere nuove classi che implementano l’interfaccia è semplice e non richiede modifiche significative al codice esistente.
3. Riusabilità del codice: Il polimorfismo facilita l’uso di funzioni generiche che possono lavorare con qualsiasi nuova classe che implementa l’interfaccia o estende la classe base.
1. [Manuale PHP ufficiale](https://www.php.net/manual/en/language.oop5.interfaces.php)
2. [W3Schools PHP OOP](https://www.w3schools.com/php/php_oop_interfaces.asp)
3. [GeeksforGeeks PHP OOP](https://www.geeksforgeeks.org/object-oriented-programming-in-php/)
Questo ti offre una visione completa e pratica di come il polimorfismo viene implementato in PHP, con esempi concreti e le fonti per ulteriori letture e approfondimenti.
