Polimorfismo tramite interfacce

Fa parte della sezione Programmazione orientata agli oggetti del percorso PHP di Coddy. Lezione 34 di 91.

Nella lezione precedente hai visto il polimorfismo tramite l'ereditarietà, in cui le classi figlie sovrascrivono i metodi delle classi genitrici. Le interfacce offrono un altro potente modo per ottenere il polimorfismo, soprattutto quando si lavora con classi non correlate che condividono un comportamento comune.

Con le interfacce, il polimorfismo deriva dal contratto stesso. Qualsiasi classe che implementa un’interfaccia garantisce di avere determinati metodi, indipendentemente dalla propria gerarchia di ereditarietà:

<?php
interface Notifiable {
    public function send(string $message);
}

class EmailNotifier implements Notifiable {
    public function send(string $message) {
        return "Email: " . $message;
    }
}

class SMSNotifier implements Notifiable {
    public function send(string $message) {
        return "SMS: " . $message;
    }
}

class PushNotifier implements Notifiable {
    public function send(string $message) {
        return "Push: " . $message;
    }
}

function notify(Notifiable $notifier, string $message) {
    return $notifier->send($message);
}

echo notify(new EmailNotifier(), "Hello") . "\n";
echo notify(new SMSNotifier(), "Hello") . "\n";
echo notify(new PushNotifier(), "Hello");

Output:

Email: Hello
SMS: Hello
Push: Hello

La funzione notify() funziona con qualsiasi oggetto Notifiable. Queste classi non condividono una classe genitore: sono completamente indipendenti, fatta eccezione per il fatto che implementano la stessa interfaccia. Questo è il vantaggio principale rispetto al polimorfismo basato sull'ereditarietà: puoi raggruppare classi non correlate in base alle loro capacità anziché alla loro gerarchia.

Punto chiave: Il polimorfismo basato sulle interfacce consente di usare in modo intercambiabile classi non correlate in base al comportamento condiviso, rendendo il codice più flessibile e disaccoppiato dalle implementazioni specifiche.

Sfida

Facile

Costruiamo un sistema di archiviazione che dimostri il polimorfismo basato sulle interfacce. Creerai diversi backend di archiviazione, un file system e un database, che non hanno nulla in comune, tranne il fatto che implementano entrambi la stessa interfaccia di archiviazione. Una singola funzione funzionerà con qualsiasi tipo di archiviazione, mostrando come le interfacce consentano il polimorfismo tra classi completamente estranee.

Organizzerai il codice in quattro file:

Storable.php: Definisci un'interfaccia Storable con due firme di metodo: save($key, $data) e retrieve($key). Questo contratto garantisce che qualsiasi sistema di archiviazione possa memorizzare e recuperare dati, indipendentemente da come sia implementato internamente.
FileStorage.php: Crea una classe FileStorage che implementa Storable. Includi il file dell'interfaccia. La classe dovrebbe avere una proprietà privata $directory impostata tramite il costruttore. Implementa save($key, $data) in modo che restituisca "Saving '[data]' to file [directory]/[key].txt". Implementa retrieve($key) in modo che restituisca "Reading from file [directory]/[key].txt".
DatabaseStorage.php: Crea una classe DatabaseStorage che implementa anch'essa Storable. Includi il file dell'interfaccia. La classe dovrebbe avere una proprietà privata $tableName impostata tramite il costruttore. Implementa save($key, $data) in modo che restituisca "Inserting '[data]' into table [tableName] with key [key]". Implementa retrieve($key) in modo che restituisca "Selecting from table [tableName] where key = [key]".
main.php: Includi entrambi i file di archiviazione. Crea una funzione chiamata storeData che accetti un parametro di tipo Storable, una chiave e dei dati. La funzione dovrebbe restituire il risultato della chiamata a save() con la chiave e i dati. Crea un'altra funzione chiamata fetchData che accetti un parametro di tipo Storable e una chiave, restituendo il risultato della chiamata a retrieve().

Riceverai quattro input: un percorso di directory, un nome di tabella, una chiave e alcuni dati da memorizzare. Crea un FileStorage con la directory e un DatabaseStorage con il nome della tabella. Usa la funzione storeData() per salvare i dati prima nell'archiviazione su file e poi in quella su database. Stampa ogni risultato su una riga separata. Poi usa fetchData() per recuperare i dati dall'archiviazione su file e stampa il risultato.

Nota come storeData() e fetchData() funzionino allo stesso modo con entrambi i tipi di archiviazione. Si basano solo sul fatto che l'oggetto implementi Storable. Il file system e il database hanno implementazioni interne completamente diverse, eppure sono intercambiabili grazie al contratto dell'interfaccia.

Provalo tu

<?php
require_once 'FileStorage.php';
require_once 'DatabaseStorage.php';

// Leggi gli input
$directory = trim(fgets(STDIN));
$tableName = trim(fgets(STDIN));
$key = trim(fgets(STDIN));
$data = trim(fgets(STDIN));

// TODO: Crea una funzione storeData che accetti uno Storable, key e data
// Deve restituire il risultato della chiamata a save() con key e data

// TODO: Crea una funzione fetchData che accetti uno Storable e key
// Deve restituire il risultato della chiamata a retrieve() con key

// TODO: Crea un'istanza di FileStorage con la directory

// TODO: Crea un'istanza di DatabaseStorage con il nome della tabella

// TODO: Usa storeData() per salvare i dati nell'archiviazione su file, poi stampa il risultato

// TODO: Usa storeData() per salvare i dati nell'archiviazione su database, poi stampa il risultato

// TODO: Usa fetchData() per recuperare i dati dall'archiviazione su file, poi stampa il risultato
?>