Polimorfismo em Java OOPs com Exemplo:O que é, Dinâmico

Exemplo de polimorfismo Java

Mudança no requisito de software

Etapa 1) De tal forma que quando o método “retirado” para conta poupança é chamado, um método da classe de conta pai é executado

Etapa 2) Mas quando o método “Retirada” para a conta privilegiada (facilidade de saque a descoberto) é chamado, o método de retirada definido na classe privilegiada é executado. Este é o polimorfismo em OOPs.

Sobreposição de métodos em Java

Regras para substituição de método

• A assinatura do método, ou seja, o nome do método, a lista de parâmetros e o tipo de retorno devem corresponder exatamente.
• O método substituído pode ampliar a acessibilidade, mas não reduzi-la, ou seja, se for privado na classe base, a classe filha pode torná-lo público, mas não vice-versa.

Exemplo

class Doctor{
  public void treatPatient(){
  // treatPatient method
  
}
class Surgeon extends Doctor{
  public void treatPatient(){
  // treatPatient method
  }
}
Class run{
  public static void main (String args[]){
    Doctor doctorObj = new Doctor()
	// treatPatient method in class Doctor will be executed
    doctorObj.treatPatient();
   
    Surgeon surgeonObj = new Surgeon();
    // treatPatient  method in class Surgeon  will be executed
    surgeonObj.treatPatient();
  }
}

Diferença entre sobrecarga e substituição

void sum (int a , int b);
void sum (int a , int b, int c);
void sum (float a, double b);

class X{
  public int sum(){
     // some code
  }
}

class Y extends X{
  public int sum(){
    //overridden method
   //signature is same
 }
}

O que é polimorfismo dinâmico?

Exemplo de polimorfismo dinâmico:

 Doctor obj = new Surgeon();

obj.treatPatient();

obj.treatPatient() irá executar o método treatPatient() da subclasse – Cirurgião

Se uma referência de classe base for usada para chamar um método, o método a ser invocado é decidido pela JVM, dependendo do objeto para o qual a referência está apontando

Por exemplo, embora obj seja uma referência a Doctor, ele chama o método de Surgeon, pois aponta para um objeto Surgeon

Isso é decidido durante o tempo de execução e, portanto, denominado dinâmico ou polimorfismo em tempo de execução

Diferença entre polimorfismo estático e dinâmico

void sum (int a , int b);
void sum (float a, double b);
int sum (int a, int b); //compiler gives error.

//reference of parent pointing to child object
 Doctor obj = new Surgeon();
// method of child called
obj.treatPatient();

Super palavra-chave em Java

treatPatient(){
   super.treatPatient();
     //add code specific to Surgeon
}

public class Test{
     public static void main(String args[]){
        X x= new X();
       Y y = new  Y();
       y.m2();
      //x.m1();
      //y.m1();
     //x = y;// parent pointing to object of child
     //x.m1() ;
     //y.a=10;
   }

}
class X{
   private int a;
   int b;
      public void m1(){
       System.out.println("This is method m1 of class X");
     }
}

class Y extends X{
      int c; // new instance variable of class Y
         public void m1(){
            // overriden method
            System.out.println("This is method m1 of class Y");
        }
       public void m2(){
           super.m1();
           System.out.println("This is method m2 of class Y");
      }
}

Resumo

• O polimorfismo em Programação Orientada a Objetos ocorre quando há uma ou mais classes ou objetos relacionados entre si por herança. É a capacidade de um objeto assumir muitas formas.
• A substituição de método está redefinindo um método de superclasse em uma subclasse.
• Polimorfismo dinâmico em Java é o mecanismo pelo qual vários métodos podem ser definidos com o mesmo nome e assinatura na superclasse e subclasse.
• O polimorfismo estático em Java é um tipo de polimorfismo que coleta as informações para chamar um método em tempo de compilação, enquanto o polimorfismo dinâmico é um tipo de polimorfismo que coleta as informações para chamar um método em tempo de execução.
• A palavra-chave Super pode ser usada para acessar métodos da classe pai da classe filha.