Guia Completo de Interfaces e Classes Abstratas em PHP Já leu

Classes Abstratas em PHP

Uma classe abstrata é um molde que não pode ser instanciada diretamente, servindo como base para outras classes. Ela define métodos que devem ser obrigatoriamente implementados pelas subclasses, garantindo contrato e estrutura consistente no seu código. Use-as quando você tem comportamento comum que precisa ser herdado, mas não faz sentido criar um objeto da classe pai sozinho.

abstract class Veiculo {
    protected $marca;

    abstract public function acelerar();
    abstract public function frear();

    public function __construct($marca) {
        $this->marca = $marca;
    }

    public function getMarca() {
        return $this->marca;
    }
}

class Carro extends Veiculo {
    public function acelerar() {
        return "Carro {$this->marca} acelerou!";
    }

    public function frear() {
        return "Carro {$this->marca} freou com segurança.";
    }
}

$carro = new Carro("Toyota");
echo $carro->acelerar(); // Carro Toyota acelerou!
// $veiculo = new Veiculo("Ford"); // Erro: não pode instanciar classe abstrata

Classes abstratas podem ter métodos concretos (implementados) e abstratos (apenas assinatura). As subclasses herdam o comportamento concreto e obrigatoriamente implementam os abstratos. Isso torna seu código mais robusto e reutilizável.

Interfaces em PHP

O que são e quando usar

Uma interface é um contrato que define apenas assinaturas de métodos, sem implementação. Diferente da herança (que é "é um"), interfaces definem "faz isso". Uma classe pode implementar múltiplas interfaces, mas pode herdar de apenas uma classe. Use interfaces quando quer garantir que classes diferentes façam o mesmo trabalho, independente de sua origem.

interface Pagavel {
    public function procesarPagamento($valor);
    public function obterStatusPagamento();
}

interface Rastreavel {
    public function rastrear();
}

class Pedido implements Pagavel, Rastreavel {
    private $id;
    private $status = "pendente";

    public function __construct($id) {
        $this->id = $id;
    }

    public function procesarPagamento($valor) {
        $this->status = "pago";
        return "Pagamento de R$ {$valor} processado.";
    }

    public function obterStatusPagamento() {
        return $this->status;
    }

    public function rastrear() {
        return "Pedido {$this->id} em trânsito.";
    }
}

$pedido = new Pedido(123);
echo $pedido->procesarPagamento(100); // Pagamento de R$ 100 processado.
echo $pedido->rastrear(); // Pedido 123 em trânsito.

Interfaces vs Classes Abstratas

Interfaces definem o quê fazer, abstratas definem quê e como. Use abstratas para compartilhar código entre classes relacionadas; use interfaces para estabelecer contrato entre classes diferentes. Uma classe pode implementar várias interfaces, mas herdar de apenas uma abstrata.

abstract class Animal {
    abstract public function fazer_som();

    public function dormir() {
        return "Zzz... dormindo.";
    }
}

interface Domesticavel {
    public function treinar();
}

class Cachorro extends Animal implements Domesticavel {
    public function fazer_som() {
        return "Au au!";
    }

    public function treinar() {
        return "Cachorro treinado com sucesso!";
    }
}

$dog = new Cachorro();
echo $dog->fazer_som(); // Au au!
echo $dog->dormir(); // Zzz... dormindo.
echo $dog->treinar(); // Cachorro treinado com sucesso!

Padrões de Design Práticos

Dependency Injection com Interfaces

Injetar dependências através de interfaces torna seu código flexível e testável. Em vez de instanciar objetos dentro da classe, você recebe como parâmetro uma implementação da interface.

interface RepositorioDB {
    public function salvar($dados);
    public function obter($id);
}

class Usuario {
    private $db;

    public function __construct(RepositorioDB $db) {
        $this->db = $db;
    }

    public function criar($nome, $email) {
        return $this->db->salvar(['nome' => $nome, 'email' => $email]);
    }
}

class MySQLRepository implements RepositorioDB {
    public function salvar($dados) {
        return "Salvo no MySQL: " . json_encode($dados);
    }

    public function obter($id) {
        return "Obtido do MySQL com ID: $id";
    }
}

class MockRepository implements RepositorioDB {
    public function salvar($dados) {
        return "Simulado: " . json_encode($dados);
    }

    public function obter($id) {
        return "Mock data para ID: $id";
    }
}

// Fácil trocar implementação sem mudar Usuario
$repo = new MySQLRepository();
$usuario = new Usuario($repo);
echo $usuario->criar("João", "joao@email.com");

Conclusão

Três aprendizados principais: (1) Classes abstratas são bases para famílias de classes relacionadas, garantindo que subclasses implementem métodos específicos; (2) Interfaces estabelecem contratos entre classes não relacionadas, permitindo múltiplas implementações do mesmo comportamento; (3) Usar ambas corretamente, combinadas com dependency injection, resulta em código robusto, testável e fácil de manter. Domine esses conceitos e você elevará significativamente a qualidade de suas aplicações PHP.

Referências

• PHP Manual - Abstract Classes
• PHP Manual - Interfaces
• Design Patterns PHP - Refactoring Guru
• Clean Code em PHP - Matthias Noback
• PSR-12: Extended Coding Style Guide