PHP Academy · Aula

Implementação de interfaces

Defina contratos com interface e implemente-os em várias classes.

Implementação de interfaces é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Introdução: Interfaces do PHP

Uma interface define um contrato: uma lista de assinaturas de métodos que as classes que a implementam devem fornecer. Diferentemente das classes abstratas, uma classe pode implementar várias interfaces.

Conceitos principais

Conceitos principais:

Declare com interface Name {}
Os métodos não têm corpo — apenas assinaturas
Implemente com implements InterfaceName
Uma classe pode implementar várias interfaces

Definição de uma interface

Exemplo:

<?php
interface Serializable {
    public function serialize(): string;
    public function unserialize(string $data): void;
}

interface Loggable {
    public function toLog(): string;
}

// Implementing both interfaces:
class Event implements Serializable, Loggable {
    public function __construct(private string $type, private string $data) {}
    public function serialize(): string { return json_encode(['type'=>$this->type,'data'=>$this->data]); }
    public function unserialize(string $d): void { $a = json_decode($d,true); $this->type=$a['type']; $this->data=$a['data']; }
    public function toLog(): string { return "[{$this->type}] {$this->data}"; }
}

Interface como tipo

Continuação:

<?php
interface Cache {
    public function get(string $key): mixed;
    public function set(string $key, mixed $val, int $ttl = 0): void;
    public function delete(string $key): void;
}

// Function accepts any Cache implementation:
function loadUser(int $id, Cache $cache): array {
    $key = "user:$id";
    $user = $cache->get($key);
    if (!$user) {
        $user = fetchFromDb($id);
        $cache->set($key, $user, 3600);
    }
    return $user;
}

Constantes de interface

Mais detalhes:

<?php
interface HttpMethods {
    const GET    = 'GET';
    const POST   = 'POST';
    const PUT    = 'PUT';
    const DELETE = 'DELETE';
}

class Router implements HttpMethods {
    public function addRoute(string $method, string $path, callable $handler): void {
        // ...
    }
}

$router = new Router();
$router->addRoute(HttpMethods::GET, '/users', fn() => []);

Extensão de uma interface por outra

Uso prático:

<?php
interface Readable {
    public function read(): string;
}

interface Writable {
    public function write(string $data): void;
}

// Interface can extend multiple interfaces:
interface ReadWrite extends Readable, Writable {
    public function seek(int $position): void;
}

class FileStream implements ReadWrite {
    public function read(): string    { return ''; }
    public function write(string $d): void { }
    public function seek(int $p): void { }
}

Injeção de dependências com interfaces

Avançado:

<?php
interface MailerInterface {
    public function send(string $to, string $subject, string $body): bool;
}

class SmtpMailer implements MailerInterface {
    public function send(string $to, string $subject, string $body): bool {
        // real SMTP send
        return true;
    }
}

class UserService {
    public function __construct(private MailerInterface $mailer) {}

    public function register(string $email): void {
        // save user...
        $this->mailer->send($email, 'Welcome!', 'Thanks for joining.');
    }
}

Padrão

Padrões comuns de interfaces do PHP são usados para resolver de forma organizada problemas recorrentes de design. Aplique-os de maneira consistente para obter um código legível e fácil de manter.

Quando usar

Saber quando aplicar interfaces do PHP é tão importante quanto saber como. O uso excessivo leva à complexidade; o uso insuficiente leva à duplicação.

Exemplo do mundo real

Em aplicações reais, as interfaces do PHP aparecem com frequência em estruturas, ORMs e camadas de serviço. Compreendê-las prepara você para contribuir com projetos profissionais em PHP.

Armadilhas comuns

Evite estes erros com interfaces do PHP:

As classes podem implementar várias interfaces, mas podem estender apenas uma classe
As interfaces não podem ter propriedades nem corpos de métodos (exceto métodos padrão no PHP 8)
Sempre programe para uma interface (tipo abstrato), não para uma implementação
Use interfaces para permitir a injeção de dependências e a simulação em testes

Verificação rápida

Quantas interfaces uma classe PHP pode implementar simultaneamente?

Recapitulação: Interfaces do PHP

Resumo:

As classes podem implementar várias interfaces, mas podem estender apenas uma classe
As interfaces não podem ter propriedades nem corpos de métodos (exceto métodos padrão no PHP 8)
Sempre programe para uma interface (tipo abstrato), não para uma implementação
Use interfaces para permitir a injeção de dependências e a simulação em testes

Perguntas Frequentes

A aula “Implementação de interfaces” é grátis?

Sim — o texto completo de “Implementação de interfaces” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Implementação de interfaces”?

Defina contratos com interface e implemente-os em várias classes. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Implementação de interfaces”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy