Um dos pilares da orientação a objeto é o polimorfismo, este conceito foi o último a ser pensado segundo o seu criador Alan Kay. Neste artigo entenderemos melhor como ele funciona.

 Quem já programou em C ou linguagens não orientadas a objeto sabe como a proibição de criar “funções” pode gerar problemas. Ao definir o nome de uma função ele torna-se uma chave onde não pode existir outro nome igual. Assim nomes bastante criativos, como: função1, função2… podem nascer.

O polimorfismo, assim como a orientação a objetos é bastante popular e tem vários materiais legais por ai. Veja por exemplo o curso em vídeo e fique esperto para procurar sobre isso no YouTube.

O que é Polimorfismo?

O polimorfismo é um recurso que permite ao programador utilizar o mesmo nome para os métodos.

Porém, é preciso que o programador siga algumas regras essenciais para que o polimorfismo aconteça sem que ele se perca no fluxo de dados. Em literaturas encontramos que o polimorfismo é o princípio pelo qual duas ou mais classes derivadas de uma mesma superclasse podem invocar métodos que têm a mesma identificação, assinatura, mas comportamentos distintos, especializados para cada classe derivada, usando para tanto uma referência a um objeto do tipo da superclasse.

Tipos de polimorfismo

A literatura existente apresenta duas visões sobre tipos de polimorfismo. Alguns defendem que o único polimorfismo existente é o (utiliza herança). Já outras literaturas propõem que o polimorfismo acontece também horizontalmente. 

O polimorfismo horizontal ou também conhecido como sobrecarga, não utiliza herança para ocorrer. Ele se caracteriza pela criação de métodos com a mesma chamada (nome), porém com parâmetros diferentes.

Observe o exemplo 1:

Exemplo 01:

  public class Teste {
        public void fazAlgo() {
              System.out.println("Este método não recebe parâmetro);
        }
        public void fazAlgo(String mensagem) {

              System.out.println("Mensagem");
        }
  }

No exemplo 01 percebemos que existem na classe Teste dois métodos com o mesmo nome (fazAlgo()). Isto é permitido pois eles se diferenciam pela quantidade de parâmetros e tipos de parâmetros recebidos.

O polimorfismo vertical, também conhecido como Override ou sobrescrita é caracterizado pela sobrescrita de um método da superclasse a partir da subclasse. Observe o exemplo 02.

Exemplo 02:

  public
      class Teste {
	      public void fazAlgo() {
              System.out.println("Este é o método da super classe");
        }
  }


  public class NovoTeste extends Teste {

    @Override
    public void fazAlgo() {
          System.out.println("Este é o método foi sobrescrito");
      }
  }

  public static void main(String args[]){

        Teste T = new Teste();

        T.fazAlgo(); // Retorna "Este é o método da super classe"

        TesteNovo = TN = new TesteNovo();

        TN.fazAlgo(); // Retorna "Este método foi sobrescrito"

  }

Observando o exemplo 02 percebemos que existem três classes. A primeira classe definida é denominada Teste, onde nela existe um método chamado (fazAlgo()). Já a segunda classe extende, a classe Teste e se por sua vez é denominada NovoTeste. Perceba que na classe NovoTeste existe um método anotado com @Override e possui o mesmo nome do método da classe pai, chamado fazAlgo().

É desta forma que ocorre o polimorfismo de sobrescrita. A superclasse é sobrescrita e quando a classe for instanciada e o método fazAlgo() for invocado, o compilador executará o as linhas de código presentes no método da classe filhas. 

3. Alguns detalhes

É válido lembrar alguns detalhes sobre este assunto que são recorrentes durante a construção de um sistema OO. Em Java, todos os métodos são passíveis de polimorfismo exceto em dois casos:

• Métodos declarados como final não podem ser redefinidos e, portanto, não são passíveis de invocação polimórfica da parte de seus descendentes; e
• Métodos declarados como private são implicitamente finais. 

Quando definimos uma herança, todos os métodos e atributos da superclasse são passados para a classe filha. Entretanto, se um método for sobrescrito, o método definido na classe pai não será executado mais. Caso um método não seja sobrescrito, a regra diz que será executado o método da classe pai.

Outro detalhe final é que o Java não permite herança múltipla (uma classe herdando de várias classes). Mas ele permite que uma classe seja estendida quantas vezes o programador desejar. Apesar de ser permitido, a profundidade da herança muito alta pode ser um indicativo de um sistema que não está bem modelado.