Polimorfismo em Java
Polimorfismo

Polimorfismo em Java

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.

  1. 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.

  1. 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. 

  1. 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.

 

Vinicius dos Santos

Apenas um apaixonado por Ciência da Computação e forma com que ela pode transformar vidas!

Deixe uma resposta