No artigo de hoje veremos como funciona herança e polimorfismo em PHP Orientado a Objetos, criando classes e subclasses (classes derivadas, ou classe filha) que herdam propriedades e métodos de superclasse (classe pai).

Assim como no mundo real, a palavra herança se refere ao conceito de receber algo, herdar algo de alguém. Herança aqui pode ser entendida como um mecanismo que permite construir uma nova classe com base em uma classe previamente existente, em que a nova herda automaticamente todos os atributos, comportamentos e implementações da classe-pai.

Em se tratando de herança, estamos falando de um dos maiores benefícios da Orientação a Objetos, além da capacidade de encapsulamento. Com a herança podemos reutilizar partes de código já definidos, além da agilidade, ela elimina a necessidade de duplicar ou rescrever certo código.

Essas características nos permitem ao invés de escrevermos uma estrutura totalmente nova, reaproveitar a estrutura existente mesmo que a mesma nos forneça apenas uma base abstrata para o desenvolvimento. Você verá que não é necessário reescrever códigos já escritos anteriormente, caso precise do código de alguma classe já criada, basta criar uma subclasse (classe derivada) e ela terá todas as propriedades e métodos de sua mãe (superclasse).

Além disso, você também vai aprender polimorfismo, que significa ter a capacidade de sobrescrever métodos das superclasses nas subclasses. Isso significa que você poderá ter métodos de mesmo nome na superclasse e subclasse, porém, com ações diferentes.

Se na subclasse é escrito um método com o mesmo nome do método existente na classe pai, passa a vigorar o método da classe filha (subclasse).

Para acessar os métodos sobrescritos ou membros estáticos da classe pai, utilizamos a palavra reservada parent. É importante destacar que somente os métodos protect e public podem ser reescritos.

Herança em PHP Orientado a Objetos

Como havíamos mencionado, temos superclasses e subclasses na orientação a objetos, sendo que:

A superclasse (ou classe mãe)

 class Configura { protected $valor = 'Valor qualquer'; protected function inverte ( $oque ) { return strrev( $oque ); } }

Veja que tenho uma propriedade:

 protected $valor = 'Valor qualquer';

E um método:

 protected function inverte ( $oque ) { return strrev( $oque ); } 

Perceba também, que ambos são "protected", ou seja, não podem ser acessados diretamente pelo programa, somente pela superclasse e suas subclasses.

No método, estou apenas chamando uma função que inverte os valores de uma string qualquer, com strrev.

A subclasse (ou classe filha)

 class Mostra extends Configura { public function view () { return parent::inverte( $this->valor ); } }

Essa classe não tem nenhuma propriedade, porém, tem um método públic (public) chamado view. Este método não faz nada além de retornar um valor.

O que pode ser confuso aqui, é que a subclasse acima não tem nenhuma propriedade chamada "valor", ou método chamado "inverte", e mesmo assim, consigo utilizar ambos indiretamente quando crio o objeto e chamo o método view:

 $mostra = new Mostra(); echo $mostra->view();

Isso acontece porque a subclasse herdou tudo o que continha na superclasse, tanto propriedades quanto métodos.

Para acessar propriedades da superclasse na subclasse, simplesmente utilize a palavra reservada $this.

 <?php // Superclasse class Configura { protected $valor = 'Valor qualquer'; } ?> <?php // Subclasse class Mostra extends Configura { function __construct() { // Exibe o valor da superclasse echo $this->valor; } } ?> // Objeto da subclasse $mostra = new Mostra();

Veja que $this->valor está exibindo o valor da superclasse, mesmo estando dentro da subclasse.

Porém, se você criar outra propriedade de mesmo nome na subclasse, a propriedade da superclasse será sobrescrita, e o valor da subclasse passará a valer.

 <?php // Superclasse class Configura { protected $valor = 'Valor qualquer'; } // Subclasse class Mostra extends Configura { // Agora $valor tem outro valor protected $valor = 'Outro valor'; function __construct() { // Exibe o valor da superclasse echo $this->valor; } } // Objeto da subclasse $mostra = new Mostra();

Além disso, também posso utilizar as palavras parent (para me referir à superclasse) e self (para fazer referência à classe atual, ou classe filha).

Exemplo:

 <?php // Superclasse class Configura { protected $valor = 'Valor qualquer'; // Método ver() na superclasse protected function ver () { return 'Classe mãe: ' . $this->valor . '<br>'; } } // Subclasse class Mostra extends Configura { public $valor = 'Outro valor'; function __construct() { // Exibe o valor da superclasse echo self::ver(); // Subclasse echo parent::ver(); // Superclasse echo $this->ver(); // Subclasse } // Método ver() na subclasse protected function ver () { return 'Classe filha: ' . $this->valor . '<br>'; } } // Objeto da subclasse $mostra = new Mostra();

Polimorfismo em PHP Orientado a Objetos

Polimorfismo simplesmente significa reescrever um método da superclasse na subclasse, e assim podendo determinar novos comportamentos desse método.

 <?php // Superclasse class Configura { public function ver () { echo 'Sou a superclasse! <br>'; } function __construct() { $this->ver(); } } // Subclasse class Mostra extends Configura { public function ver () { echo 'Sou a subclasse! <br>'; } function __construct() { $this->ver(); } } // Objeto da superclasse $superclasse = new Configura(); // Objeto da subclasse $subclasse = new Mostra();

O método "ver( )", foi reescrito na subclasse, por isso, terá um resultado diferente da sua classe mãe, a superclasse.

Se eu apagar o método da subclasse, teremos duas vezes a mensagem: "Sou a superclasse!" na tela.

 <?php // Superclasse class Configura { public function ver () { echo 'Sou a superclasse! <br>'; } function __construct() { $this->ver(); } } // Subclasse class Mostra extends Configura { function __construct() { $this->ver(); } } // Objeto da superclasse $superclasse = new Configura(); // Objeto da subclasse $subclasse = new Mostra();

Com estes recursos, expandimos nosso código, sem reescrevê-lo, isso é extremamente comum quando se trata de criar novas funcionalidades em um software, e com certeza seu código ficará mais bonito e fácil de entender.

Dúvidas, críticas ou sugestões comentem abaixo. =)