Polimorfismo via Interfaces

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy — lição 34 de 91.

Na lição anterior, você viu o polimorfismo por meio da herança, onde as classes filhas sobrescrevem os métodos das classes pai. As interfaces fornecem outra maneira poderosa de alcançar o polimorfismo, especialmente ao trabalhar com classes não relacionadas que compartilham um comportamento comum.

Com interfaces, o polimorfismo vem do próprio contrato. Qualquer classe que implemente uma interface garante que possui certos métodos, independentemente de sua hierarquia de herança:

<?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");

Saída:

Email: Hello
SMS: Hello
Push: Hello

A função notify() funciona com qualquer objeto Notifiable. Essas classes não compartilham uma classe pai - elas são completamente não relacionadas, exceto por implementarem a mesma interface. Esta é a principal vantagem sobre o polimorfismo baseado em herança: você pode agrupar classes não relacionadas por suas capacidades, em vez de sua ancestralidade.

Ponto Chave: O polimorfismo baseado em interface permite que classes não relacionadas sejam usadas de forma intercambiável com base em comportamento compartilhado, tornando seu código mais flexível e desacoplado de implementações específicas.

Desafio

Fácil

Vamos construir um sistema de armazenamento que demonstra o polimorfismo baseado em interfaces. Você criará diferentes backends de armazenamento — um sistema de arquivos e um banco de dados — que não têm nada em comum, exceto pelo fato de ambos implementarem a mesma interface de armazenamento. Uma única função funcionará com qualquer tipo de armazenamento, mostrando como as interfaces permitem o polimorfismo entre classes completamente não relacionadas.

Você organizará seu código em quatro arquivos:

Storable.php — Defina uma interface Storable com duas assinaturas de método: save($key, $data) e retrieve($key). Este contrato garante que qualquer sistema de armazenamento possa armazenar e recuperar dados, independentemente de como seja implementado internamente.
FileStorage.php — Crie uma classe FileStorage que implementa Storable. Inclua o arquivo da interface. A classe deve ter uma propriedade privada $directory definida através do construtor. Implemente save($key, $data) para retornar "Saving '$data' to file $this->directory/$key.txt". Implemente retrieve($key) para retornar "Reading from file $this->directory/$key.txt".
DatabaseStorage.php — Crie uma classe DatabaseStorage que também implementa Storable. Inclua o arquivo da interface. A classe deve ter uma propriedade privada $tableName definida através do construtor. Implemente save($key, $data) para retornar "Inserting '$data' into table $this->tableName with key $key". Implemente retrieve($key) para retornar "Selecting from table $this->tableName where key = $key".
main.php — Inclua ambos os arquivos de armazenamento. Crie uma função chamada storeData que aceita um parâmetro Storable, uma chave e dados. A função deve retornar o resultado da chamada de save() com a chave e os dados. Crie outra função chamada fetchData que aceita um parâmetro Storable e uma chave, retornando o resultado da chamada de retrieve().

Você receberá quatro entradas: um caminho de diretório, um nome de tabela, uma chave e alguns dados para armazenar. Crie um FileStorage com o diretório e um DatabaseStorage com o nome da tabela. Use sua função storeData() para salvar os dados usando o armazenamento de arquivo primeiro, depois o armazenamento de banco de dados. Imprima cada resultado em sua própria linha. Em seguida, use fetchData() para recuperar do armazenamento de arquivo e imprima esse resultado.

Observe como storeData() e fetchData() funcionam de forma idêntica com ambos os tipos de armazenamento — eles apenas se importam que o objeto implemente Storable. O sistema de arquivos e o banco de dados têm implementações internas completamente diferentes, mas são intercambiáveis através do contrato da interface.

Folha de consulta

Interfaces permitem o polimorfismo ao permitir que classes não relacionadas sejam usadas de forma intercambiável com base no comportamento compartilhado, em vez da hierarquia de herança.

Qualquer classe que implementa uma interface garante que possui certos métodos, criando um contrato que possibilita o comportamento polimórfico:

<?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;
    }
}

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

echo notify(new EmailNotifier(), "Hello");
echo notify(new SMSNotifier(), "Hello");

A função notify() aceita qualquer objeto que implemente Notifiable, independentemente da hierarquia de classes. Isso torna o código mais flexível e desacoplado de implementações específicas.

Vantagem principal: O polimorfismo baseado em interface agrupa classes não relacionadas por suas capacidades, não por sua ancestralidade, permitindo que implementações completamente diferentes sejam usadas de forma intercambiável por meio de um contrato comum.

Experimente você mesmo

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

// Ler entradas
$directory = trim(fgets(STDIN));
$tableName = trim(fgets(STDIN));
$key = trim(fgets(STDIN));
$data = trim(fgets(STDIN));

// TODO: Criar uma função storeData que aceite um Storable, chave e dados
// Ela deve retornar o resultado da chamada de save() com a chave e os dados

// TODO: Criar uma função fetchData que aceite um Storable e uma chave
// Ela deve retornar o resultado da chamada de retrieve() com a chave

// TODO: Criar uma instância de FileStorage com o diretório

// TODO: Criar uma instância de DatabaseStorage com o nome da tabela

// TODO: Usar storeData() para salvar dados com o armazenamento em arquivo e imprimir o resultado

// TODO: Usar storeData() para salvar dados com o armazenamento em banco de dados e imprimir o resultado

// TODO: Usar fetchData() para recuperar do armazenamento em arquivo e imprimir o resultado
?>