interface

A Palavra-chave interface do PHP

Uma interface é um contrato: ela lista os métodos que uma classe deve fornecer, sem dizer como eles funcionam. Qualquer classe que implements a interface se compromete a definir todos os métodos declarados por ela. Isso permite que você programe em torno de uma capacidade ("qualquer coisa que possa ser registrada", "qualquer coisa que possa ser serializada") em vez de uma classe concreta.

Interfaces não podem ser instanciadas diretamente — não há implementação para executar. Elas existem para que classes não relacionadas possam ser tratadas de forma intercambiável, desde que compartilhem as mesmas assinaturas de método.

Esta página cobre como declarar uma interface, implementar uma ou várias, compartilhar constantes, estender interfaces e verificar tipos em tempo de execução com instanceof. Se você é novo em objetos em PHP, comece com classes e objetos PHP e o que é OOP.

Sintaxe

Aqui está a sintaxe básica para declarar uma interface:

interface MyInterface {
  public function someMethod();
}

Isso declara uma interface MyInterface com um único método someMethod(). Regras principais:

• Os corpos dos métodos são omitidos — uma interface declara apenas assinaturas, terminando cada uma com ponto e vírgula.
• Todos os métodos são implicitamente públicos; você pode escrever public para maior clareza, mas nenhuma outra visibilidade é permitida (private/protected são proibidos).
• Uma classe adota uma interface com a palavra-chave implements e deve definir todos os métodos, ou o PHP gera um erro fatal.

Exemplos

Vejamos alguns exemplos práticos de como a palavra-chave interface pode ser usada. A primeira classe implementa uma interface; a segunda implementa duas ao mesmo tempo (separadas por vírgulas):

<?php

// Example 1
interface MyInterface {
  public function someMethod();
}
class MyClass implements MyInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
}

$obj = new MyClass();
$obj->someMethod();

// Output: This is from someMethod.

// Example 2
interface MyOtherInterface {
  public function someOtherMethod();
}
class MyOtherClass implements MyInterface, MyOtherInterface {
  public function someMethod() {
    echo "This is from someMethod." . PHP_EOL;
  }
  public function someOtherMethod() {
    echo "This is from someOtherMethod." . PHP_EOL;
  }
}

$obj2 = new MyOtherClass();
$obj2->someMethod();
$obj2->someOtherMethod();

// Output:
// This is from someMethod.
// This is from someOtherMethod.

Nestes exemplos, definimos interfaces e as usamos em nossas classes PHP para garantir que as classes implementem os métodos obrigatórios.

Constantes de interface

Uma interface pode declarar constantes que toda classe implementadora herda. Elas são sempre públicas e não podem ser substituídas, o que as torna úteis para valores fixos compartilhados:

<?php

interface HttpStatus {
  const OK = 200;
  const NOT_FOUND = 404;
}

class Response implements HttpStatus {
  public function describe(): string {
    return "Status " . self::OK;
  }
}

echo (new Response())->describe() . PHP_EOL;
echo HttpStatus::NOT_FOUND . PHP_EOL;

// Output:
// Status 200
// 404

Para constantes que podem ser substituídas, use constantes de classe dentro de uma classe.

Estendendo interfaces

Ao contrário das classes, uma interface pode extend múltiplas outras interfaces. A interface combinada exige então todos os métodos de cada pai:

<?php

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

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

// A single interface that demands both capabilities
interface ReadWrite extends Readable, Writable {}

class File implements ReadWrite {
  private string $buffer = "";
  public function read(): string { return $this->buffer; }
  public function write(string $data): void { $this->buffer = $data; }
}

$f = new File();
$f->write("hello");
echo $f->read() . PHP_EOL;

// Output: hello

É assim que o PHP simula herança múltipla — veja herança PHP para herança de classe única com extends.

Type hints e instanceof

Como qualquer classe implementadora satisfaz a interface, você pode usar type hints da interface em assinaturas de função e aceitar qualquer objeto correspondente. Use instanceof para verificar em tempo de execução:

<?php

interface Shape {
  public function area(): float;
}

class Circle implements Shape {
  public function __construct(private float $r) {}
  public function area(): float { return 3.14159 * $this->r ** 2; }
}

function printArea(Shape $shape): void {
  echo round($shape->area(), 2) . PHP_EOL;
}

$c = new Circle(2);
printArea($c);
var_dump($c instanceof Shape);

// Output:
// 12.57
// bool(true)

Interface vs. classe abstrata

Ambas definem um contrato, mas resolvem problemas diferentes:

• Uma interface declara apenas assinaturas de métodos e uma classe pode implementar muitas delas. Use-a para descrever uma capacidade compartilhada por classes não relacionadas.
• Uma classe abstrata pode fornecer métodos e propriedades concretos, além de abstratos, mas uma classe pode estender apenas uma. Use-a para compartilhar implementação entre classes relacionadas.

Quando você precisa compartilhar código entre classes sem herança, recorra a traits.

Benefícios

Usar a palavra-chave "interface" traz vários benefícios, incluindo:

• Desacoplamento e flexibilidade: Interfaces permitem trocar implementações sem modificar o código dependente, tornando o sistema mais adaptável.
• Testes mais fáceis: Elas possibilitam mocking e stubbing, o que simplifica os testes unitários e a depuração.
• Simulação de herança múltipla: Como o PHP não suporta herança múltipla de classes, uma classe pode implementar múltiplas interfaces para herdar contratos de comportamento de várias fontes.

Conclusão

A palavra-chave interface permite definir um contrato de métodos obrigatórios que qualquer classe pode implementar, independentemente de sua posição na hierarquia de classes. Combinadas com type hints e instanceof, as interfaces tornam o código mais flexível, testável e desacoplado. Recorra a uma interface quando quiser descrever uma capacidade; recorra a uma classe abstrata quando também precisar compartilhar implementação.

Prática