Polimorfismo em PHP

O polimorfismo é um dos pilares fundamentais da programação orientada a objetos (POO) em PHP. Ele permite que diferentes classes utilizem métodos com o mesmo nome, mas comportamentos distintos, dependendo do contexto. Isso facilita a criação de código flexível e reutilizável, permitindo que objetos de diferentes tipos possam ser tratados de forma unificada. Neste post, vamos entender o que é polimorfismo, como implementá-lo e quais os benefícios para o seu código em PHP.

O que é Polimorfismo?

A palavra polimorfismo vem do grego e significa “muitas formas”. No contexto da programação, significa que objetos de diferentes classes podem ser tratados da mesma maneira, desde que herdem ou implementem métodos comuns. O polimorfismo permite que você chame o mesmo método em diferentes tipos de objetos e tenha comportamentos diferentes.

Em PHP, o polimorfismo é conseguido através de herança ou interfaces, permitindo que uma classe filha ou uma implementação de uma interface possa sobrescrever o comportamento de um método da classe base ou interface.

Polimorfismo com herança

O exemplo mais comum de polimorfismo é quando classes herdam de uma classe base e sobrescrevem métodos. O polimorfismo é útil quando você pode tratar objetos derivados de diferentes classes de forma semelhante.

Exemplo de polimorfismo com herança:

<?php
// Classe base
class Animal {
    public function fazerSom() {
        return "Som desconhecido";
    }
}

// Classes derivadas
class Cachorro extends Animal {
    public function fazerSom() {
        return "Latido";
    }
}

class Gato extends Animal {
    public function fazerSom() {
        return "Miau";
    }
}

// Função que utiliza o polimorfismo
function emitirSom(Animal $animal) {
    echo $animal->fazerSom() . "<br>";
}

// Teste de polimorfismo
$cachorro = new Cachorro();
$gato = new Gato();

emitirSom($cachorro);  // Exibe: Latido
emitirSom($gato);      // Exibe: Miau
?>

Explicação:

• A função emitirSom() aceita qualquer objeto do tipo Animal, mas ao chamar o método fazerSom(), ela exibe o som específico de cada tipo de animal (Cachorro e Gato).
  
  
• Isso demonstra o polimorfismo, já que a mesma função (emitirSom) pode ser aplicada a diferentes classes, e cada classe pode fornecer sua própria implementação do método fazerSom().

Polimorfismo com interfaces

Outro exemplo de polimorfismo é quando diferentes classes implementam a mesma interface. Isso permite que diferentes classes sejam tratadas da mesma forma, garantindo que elas tenham os métodos definidos pela interface, mas com implementações diferentes.

Exemplo de polimorfismo com interfaces:

<?php
// Definindo a interface
interface Forma {
    public function calcularArea();
}

// Implementação da interface por classes diferentes
class Circulo implements Forma {
    private $raio;
    
    public function __construct($raio) {
        $this->raio = $raio;
    }
    
    public function calcularArea() {
        return pi() * pow($this->raio, 2);
    }
}

class Retangulo implements Forma {
    private $largura;
    private $altura;
    
    public function __construct($largura, $altura) {
        $this->largura = $largura;
        $this->altura = $altura;
    }
    
    public function calcularArea() {
        return $this->largura * $this->altura;
    }
}

// Função que utiliza polimorfismo com interface
function exibirArea(Forma $forma) {
    echo "Área: " . $forma->calcularArea() . "<br>";
}

// Teste de polimorfismo
$circulo = new Circulo(5);
$retangulo = new Retangulo(4, 6);

exibirArea($circulo);    // Exibe: Área: 78.5398
exibirArea($retangulo);  // Exibe: Área: 24
?>

Explicação:

• A interface Forma define um contrato que exige que qualquer classe que a implemente tenha o método calcularArea().
  
  
• Tanto Circulo quanto Retangulo implementam essa interface, mas o cálculo da área para cada forma é diferente.
  
  
• A função exibirArea() aceita qualquer objeto que implemente a interface Forma, permitindo um comportamento polimórfico

Vantagens do polimorfismo

1. Facilidade de extensão: Ao usar polimorfismo, você pode adicionar novas classes que se comportam de forma semelhante sem alterar o código existente. Isso permite a extensão de funcionalidades sem a necessidade de modificações significativas no código já implementado.
   
   
2. Código flexível: Ao invés de verificar manualmente o tipo de cada objeto, você pode tratar diferentes tipos de objetos de maneira uniforme. Isso simplifica o código e evita longas cadeias de condições (if-else ou switch).
   
   
3. Reutilização de código: O polimorfismo promove a reutilização de código, já que métodos e classes podem ser aplicados a diferentes objetos, sem a necessidade de duplicação de lógica.

Quando usar polimorfismo

Você deve usar polimorfismo quando precisar que diferentes classes compartilhem a mesma interface ou comportamento, mas tenham implementações específicas. Ele é particularmente útil quando você está criando bibliotecas ou frameworks que devem ser flexíveis e permitir a adição de novas funcionalidades sem grandes refatorações.

Outro exemplo prático

Por meio de classes-pai e filhas, as classes finais podem retroceder gerações e se comportar como as classes anteriores a elas, mas utilizando suas informações e seus atributos:

 abstract class Animal {
  
  public function ruido() {
    return "rosnar";
  }
  
  public function mover() {
    return "anda";
  }
 }
 
 class Gato extends Animal {
   
   public function ruido() { //O comportamento do método ruido foi alterado
     return "mia";
   }
 }
 
  class Passaro extends Animal {
   
   public function ruido() { //O comportamento do método ruido foi alterado
     return "canta";
   }     
   
   /* O comportamento do método mover foi alterado e o método mover 
   da classe pai foi chamado (parent::mover() ) */
   public function mover() { 
     return "voa". " e " . parent::mover();
   }     
 }
 
 $mingal = new Gato();
 echo $mingal->ruido(); //Mostra "mia"

 $ze = new Passaro();
 echo $ze->ruido(); //Mostra "canta"

 $ze = new Passaro();
 echo $ze->mover();//Mostra "voa e anda"

O polimorfismo é uma ferramenta poderosa da programação orientada a objetos, permitindo a criação de sistemas mais flexíveis e fáceis de manter.

Ele permite que diferentes classes compartilhem a mesma interface ou herdem de uma classe base, mas ainda tenham comportamentos específicos. Em PHP, o polimorfismo pode ser implementado tanto com herança quanto com interfaces, oferecendo grande flexibilidade no design de software.

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: polimorfismo