Como funcionam herança, classes abstratas e interfaces?

Question

Accepted Answer

PHP oferece suporte a herança OOP e abstração através de três mecanismos relacionados: **herança de classe** (`extends`), **classes abstratas** (classes base parciais) e **interfaces** (contratos). Cada um serve a um propósito de design diferente.

## Herança — estender uma classe pai

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

Uma subclasse `extends` uma classe pai, herdando e opcionalmente sobrescrevendo seus membros. `parent::` chama o método pai sobrescrito. PHP oferece suporte a **herança única** (apenas um pai).

## Classes abstratas — uma base parcial (não pode ser instanciada)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

Uma **classe abstrata** mescla métodos abstratos (subclasses devem implementar) com código concreto compartilhado — uma base que não pode ser instanciada diretamente.

## Interfaces — contratos puros (múltiplos permitidos)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

Uma **interface** define um contrato (assinaturas de método, sem implementação). Uma classe pode `implement` **muitas** interfaces — a forma do PHP contornar a herança única para compartilhar capacidades.

## Quando usar cada uma

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Por que isso importa

Herança, classes abstratas e interfaces são ferramentas centrais de OOP, e compreender as distinções é importante para projetar aplicações PHP bem estruturadas (e para trabalhar com frameworks, que dependem muito desses conceitos). **Herança** (`extends`) fornece reutilização de código através de relações "é-um", mas PHP permite apenas herança única. **Classes abstratas** fornecem uma base compartilhada com código implementado e métodos que subclasses devem definir — bom para classes intimamente relacionadas que compartilham lógica. **Interfaces** definem contratos/capacidades, e crucialmente uma classe pode implementar **muitas** delas — tornando interfaces a chave para designs flexíveis e desacoplados, e a resposta do PHP à limitação de herança única.

Saber quando usar cada uma (herança para reutilização "é-um", classes abstratas para implementação parcial compartilhada, interfaces para contratos/capacidades), e o princípio de **programar para interfaces** (depender de abstrações para código testável, flexível e amigável com frameworks), é conhecimento importante para design OOP em PHP.

Esses mecanismos fundamentam como frameworks como Laravel e Symfony estruturam seu código (interfaces e classes base abstratas em toda parte), tornando-os essenciais tanto para projetar seu próprio código bem quanto para entender os frameworks sobre os quais você constrói.