Polimorfismo e Herança no PHP

Olá meus amigos e amigas tudo bem? Hoje vou falar de um assunto atípico dos meus posts... hoje vou falar sobre Polimorfismo e Herança no PHP. E se você acha que não existe isso no php tome cuidado com o que fala, o php vem evoluindo muito!

Uma classe é uma estrutura básica para a criação de objetos ou seja, vários objetos podem ser criados seguindo a mesma estrutura, porém com dados diferentes. 
Em algumas casos é necessários ter objetos idênticos com algumas funcionalidades a mais ou então com as mesmas funcionalidades, mas com comportamentos diferentes...

Herança

O que será esse carinha? Herança faz parte de um dos 3 pilares da POO uma herança é a
forma de um filho obter características do pai na vida real concorda? Na POO também é assim...

Por exemplo um carro e uma moto possuem características bem parecidas. Ambos possuem rodas e marchas que são semelhantes em qualquer veículo.
Pensando assim podemos dizer que carro é um veículo, assim como uma moto também é um veículo concordam? Logo carro e moto herdam características de veículo.

Esse exemplo é muito simples no php, e para herdar de uma classe utilizamos o 'extends' veja:

1. <?php
2. class Veiculo
3. {
4.         private $marcha;
6.         private $quantidadeRodas;
8.         public function passarMarcha()
9.         {
10.                 // código
11.         }
13.         public function andar()
14.         {
15.                 // código
16.         }
17. }
19. class Carro extends Veiculo
20. {
21.         public function __construct()
22.         {
23.                 $this->quantidadeRodas = 4;
24.         }
25. }
27. $carro = new Carro();
28. $carro->andar();
29. 
    

Veja só, criamos a classe veículo com atributos marcha e quantidadedeRodas e criamos uma classe carro que extende da veículo já com o construtor montando a quantidade de rodas. simples não? Herança SUALINDA :D


Polimorfismo

Poli o que? Oo'
POLIMORFISMO! Mas o que é isso? Vamos primeiro entender a palavra, polimorfismo significa muitas formas (poli: muitas, morphos: formas). Esse conceito é perfeito pois na POO significa que várias classes podem possuir a mesma estrutura e comportamentos diferentes. Quando utilizamos herança não apenas podemos reutilizar métodos da classe pai, como também podemos sobreescrever os métodos da classe pai, fazendo assim com que certas características sejam modificadas para a determinada classe.

Vamos imaginar que um banco possui dois tipos de cheques; o chque comum e o especial. Os dois possuem a mesma estrutura o que diferencia um do outro é a forma de cobrança de juros. O comum cobra 25% em cima do valor e o cheque especial o valor dos juros de 10% como podemos fazer sem escrever a mesma coisa? Assim:

1. 
   <?php
2. class ChequeComum
3. {
4.     protected $valor;
6.         // ... outros métodos da classe
8.         public function setValor( $valor )
9.         {
10.                 $this->valor = $valor;
11.         }
13.         public function getValor()
14.         {
15.                 return $this->valor;
16.         }
18.         public function calculaJuros()
19.         {
20.                 return $this->valor * 1.25; // soma 25% em cima do valor
21.         }
22. }
24. class ChequeEspecial extends ChequeComum
25. {
26.         public function calculaJuros()
27.         {
28.                 return $this->valor * 1.10; // soma 10% em cima do valor
29.         }
30.        
31.         public function calculaJurosPai(){
32.                 return $this->valor = parent::calculaJuros();
33.         }
34. }
36. $cheque = new ChequeEspecial();
37. $cheque->setValor(1000);
39. //CHAMANDO DA PRÓPRIA CLASSE
40. echo $cheque->calculaJuros();
42. echo "<hr>";
44. //CHAMANDO DA CLASSE PAI
45. echo $cheque->calculaJurosPai();

Antes de mais nada veja que na classe ChequeComum criei o atributo $valor com o acesso 'protect' ou seja, disse que ele é protegido assim pode ser acessado pela própria classe e classes que 'ligam' ela.

Perceba que na classe ChequeEspecial eu criei um método chamado calculaJurosPai ele foi apena para mostrar que se existir a necessidade do uso de um método sobrescrito devemos acessar ele paralelamente dessa forma (parent::).
Como exemplo eu criei o objeto e exibi os dois calcula juros...

Legal não é? Agora utilize =]

Obrigado e até a próxima