<h2>Herança em PHP: Fundamentos e Prática</h2>
<p>Herança é um dos pilares da Programação Orientada a Objetos. Permite que uma classe filha herde atributos e métodos de uma classe pai, eliminando duplicação de código e criando hierarquias lógicas. Em PHP, usamos a palavra-chave <code>extends</code> para estabelecer essa relação.</p>
<pre><code class="language-php">class Veiculo {
protected $marca;
protected $velocidade = 0;
public function __construct($marca) {
$this->marca = $marca;
}
public function acelerar() {
$this->velocidade += 10;
return "Acelerou para {$this->velocidade} km/h";
}
public function getMarca() {
return $this->marca;
}
}
class Carro extends Veiculo {
private $portas;
public function __construct($marca, $portas) {
parent::__construct($marca);
$this->portas = $portas;
}
public function abrirBagagem() {
return "Bagagem aberta no {$this->marca}";
}
}
$carro = new Carro("Toyota", 4);
echo $carro->acelerar(); // Acelerou para 10 km/h
echo $carro->abrirBagagem(); // Bagagem aberta no Toyota</code></pre>
<p>Note que usamos <code>protected</code> para atributos que a classe filha precisa acessar, e <code>parent::</code> para chamar métodos da classe pai. Isso garante encapsulamento sem bloquear o acesso necessário.</p>
<h3>Visibilidade e Modificadores</h3>
<p>A escolha correta entre <code>public</code>, <code>protected</code> e <code>private</code> é fundamental. Use <code>protected</code> para membros que classes filhas devem acessar, <code>private</code> para dados sensíveis que nunca mudarão, e <code>public</code> apenas quando necessário expor a interface.</p>
<h2>Polimorfismo: Múltiplas Formas, Uma Interface</h2>
<p>Polimorfismo permite que objetos de diferentes classes respondam ao mesmo método de formas distintas. É a capacidade de uma classe filha sobrescrever (override) métodos da classe pai, mantendo a mesma assinatura.</p>
<pre><code class="language-php">abstract class Animal {
protected $nome;
public function __construct($nome) {
$this->nome = $nome;
}
abstract public function fazer_som();
public function apresentar() {
return "Sou o {$this->nome}";
}
}
class Cachorro extends Animal {
public function fazer_som() {
return "{$this->nome} faz: Au au!";
}
}
class Gato extends Animal {
public function fazer_som() {
return "{$this->nome} faz: Miau!";
}
}
$animais = [
new Cachorro("Rex"),
new Gato("Félix")
];
foreach ($animais as $animal) {
echo $animal->fazer_som() . "\n";
// Rex faz: Au au!
// Félix faz: Miau!
}</code></pre>
<p>Aqui usamos uma classe <code>abstract</code> com um método <code>abstract</code>, forçando que subclasses implementem <code>fazer_som()</code>. Cada animal responde diferentemente ao mesmo método. Isso é polimorfismo em ação.</p>
<h3>Tipagem e Type Hints</h3>
<p>PHP 7+ permite definir tipos de retorno e parâmetros. Combine isso com polimorfismo para código mais robusto:</p>
<pre><code class="language-php">interface Voo {
public function decolar(): string;
public function pousar(): string;
}
class Aviao implements Voo {
public function decolar(): string {
return "Avião decolando...";
}
public function pousar(): string {
return "Avião pousando...";
}
}
function executarVoo(Voo $veiculo): void {
echo $veiculo->decolar() . "\n";
echo $veiculo->pousar() . "\n";
}
executarVoo(new Aviao());</code></pre>
<p>Usando <code>interface</code> e type hints, garantimos que qualquer classe que implemente <code>Voo</code> funcionará com <code>executarVoo()</code>. Isso é polimorfismo paramétrico.</p>
<h2>Casos Práticos: Quando Usar</h2>
<h3>Herança vs. Composição</h3>
<p>Nem sempre herança é a melhor solução. Prefira composição quando a relação não é claramente "é um(a)":</p>
<pre><code class="language-php"></code></pre>
<p>Use herança para relações "é um(a)" (Carro é Veiculo) e composição para relações "tem um(a)" (Carro tem Motor).</p>
<h3>Exemplo Real: Sistema de Pagamento</h3>
<pre><code class="language-php">abstract class Pagamento {
protected $valor;
protected $status = 'pendente';
public function __construct($valor) {
$this->valor = $valor;
}
abstract public function processar(): bool;
public function getStatus(): string {
return $this->status;
}
}
class PagamentoCartao extends Pagamento {
private $numero;
public function __construct($valor, $numero) {
parent::__construct($valor);
$this->numero = $numero;
}
public function processar(): bool {
// Simula validação
if (strlen($this->numero) === 16) {
$this->status = 'aprovado';
return true;
}
$this->status = 'rejeitado';
return false;
}
}
class PagamentoPixel extends Pagamento {
public function processar(): bool {
$this->status = 'aprovado';
return true;
}
}
function realizarVenda(Pagamento $metodo): void {
if ($metodo->processar()) {
echo "Venda finalizada - Status: " . $metodo->getStatus();
} else {
echo "Falha na venda - Status: " . $metodo->getStatus();
}
}
realizarVenda(new PagamentoCartao(150, '1234567890123456'));
realizarVenda(new PagamentoPixel(200));</code></pre>
<p>Este exemplo mostra como polimorfismo permite adicionar novos métodos de pagamento sem modificar <code>realizarVenda()</code>. Respeita o princípio Open/Closed.</p>
<h2>Conclusão</h2>
<p>Herança e polimorfismo são ferramentas poderosas quando usadas corretamente. <strong>Primeiro aprendizado</strong>: use herança para relações hierárquicas reais, não para reutilização de código superficial. <strong>Segundo</strong>: polimorfismo permite escrever código flexível e extensível que funciona com múltiplas classes através da mesma interface. <strong>Terceiro</strong>: combine com interfaces e classes abstratas para criar contratos claros e manuteníveis. Dominar esses conceitos elevará significativamente a qualidade da sua arquitetura de software.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://www.php.net/manual/pt_BR/language.oop5.php" target="_blank" rel="noopener noreferrer">PHP: Classes e Objetos - Documentação Oficial</a></li>
<li><a href="https://www.php.net/manual/pt_BR/language.oop5.inheritance.php" target="_blank" rel="noopener noreferrer">PHP: Herança - Manual</a></li>
<li><a href="https://www.php.net/manual/pt_BR/language.oop5.interfaces.php" target="_blank" rel="noopener noreferrer">PHP: Interfaces - Manual</a></li>
<li><a href="https://laracasts.com/series/object-oriented-bootcamp-in-php" target="_blank" rel="noopener noreferrer">SOLID Principles in PHP - Laracasts</a></li>
<li><a href="https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882" target="_blank" rel="noopener noreferrer">Clean Code: A Handbook of Agile Software Craftsmanship - Robert C. Martin</a></li>
</ul>