Polimorfismo dentro Java (Statico e Dinamico)

In cosa consiste il polimorfismo Java?

Polimorfismo in Java si verifica quando ci sono una o più classi o oggetti legati tra loro per ereditarietà. È la capacità di un oggetto di assumere molte forme. L'ereditarietà consente agli utenti di ereditare attributi e metodi e il polimorfismo utilizza questi metodi per eseguire attività diverse. Quindi l’obiettivo è la comunicazione, ma l’approccio è diverso.

Ad esempio, hai uno smartphone per comunicare. La modalità di comunicazione che scegli potrebbe essere qualsiasi cosa. Può essere una chiamata, un messaggio di testo, un messaggio con immagine, una posta, ecc. Quindi, l'obiettivo è comune, ovvero la comunicazione, ma il loro approccio è diverso. Questo è chiamato Polimorfismo. Ora impareremo il polimorfismo Java con esempio.

Clicchi qui se il video non è accessibile

Java Polimorfismo negli OOP con esempio

Abbiamo una classe padre, 'Account' con funzione di deposito e prelievo. Account ha 2 classi figlio. L'operazione di deposito e prelievo è la stessa per i conti di risparmio e di controllo. Quindi i metodi ereditati dalla classe Account funzioneranno.

Modifica dei requisiti software

C'è un cambiamento nella specifica dei requisiti, qualcosa che è così comune nel settore del software. Dovresti aggiungere la funzionalità Conto bancario privilegiato con funzione di scoperto. Per un background, lo scoperto è una funzione in cui puoi prelevare un importo superiore al saldo disponibile nel tuo conto. Quindi, il metodo di prelievo per i privilegiati deve essere implementato di nuovo. Ma non modifichi il pezzo di codice testato nel conto di risparmio e di controllo. Questo è un vantaggio di OOPS

Passo 1) In modo tale che quando viene chiamato il metodo "ritirato" per il conto di risparmio, viene eseguito un metodo dalla classe del conto padre

Passo 2) Ma quando il metodo "Prelievo" per il conto privilegiato (facoltà di scoperto) viene chiamato, viene eseguito il metodo di prelievo definito nella classe privilegiata. Questo è Polimorfismo negli OOP.

Metodo Override in Java

Il metodo Overriding sta ridefinendo un metodo di superclasse in una sottoclasse.

Regole per la sostituzione del metodo

• La firma del metodo, ovvero il nome del metodo, l'elenco dei parametri e il tipo restituito, devono corrispondere esattamente.
• Il metodo sovrascritto può ampliare l'accessibilità ma non restringerla, ovvero se è privato nella classe base, la classe figlia può renderlo pubblico ma non viceversa.

Esempio

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();
  }
}

Differenza tra sovraccarico e override

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
 }
}

Cos'è il polimorfismo dinamico?

Il polimorfismo dinamico negli OOP è il meccanismo mediante il quale è possibile definire più metodi con lo stesso nome e firma nella superclasse e nella sottoclasse. La chiamata a un metodo sottoposto a override viene risolta in fase di esecuzione.

Esempio di polimorfismo dinamico:

Una variabile di riferimento della super classe può fare riferimento a un oggetto della sottoclasse

 Doctor obj = new Surgeon();

Considera la dichiarazione

obj.treatPatient();

Qui la variabile di riferimento "obj" appartiene alla classe genitore, ma l'oggetto a cui punta appartiene alla classe figlia (come mostrato nell'esempio di polimorfismo seguente).

obj.treatPatient() eseguirà il metodo TreatPatient() della sottoclasse – Chirurgo

Se viene utilizzato un riferimento alla classe base per chiamare un metodo, il metodo da invocare viene deciso dalla JVM, a seconda dell'oggetto a cui punta il riferimento

Ad esempio, anche se obj è un riferimento a Doctor, richiama il metodo Surgeon, poiché punta a un oggetto Surgeon

Questo viene deciso durante il runtime e quindi definito dinamico or polimorfismo in fase di esecuzione

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 parola chiave in Java

Cosa succede se il metodo treatPatient nella classe Surgeon vuole eseguire la funzionalità definita nella classe Doctor e poi eseguire la sua specifica funzionalità? In questo caso, la parola chiave superpuò essere utilizzato per accedere ai metodi della classe padre dalla classe figlia. Il metodo treatPatient nella classe Surgeon potrebbe essere scritto come:

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

La parola chiave super può essere utilizzata per accedere a qualsiasi membro dati o metodo della super classe nella sottoclasse.

Successivamente, impareremo la parola chiave Super, Eredità e Polimorfismo in Java con programmi di esempio.

Esempio:-Per imparare l'ereditarietà, il polimorfismo e la super parola chiave

Passo 1) Copia il seguente codice in un editor

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");
      }
}

Passo 2) Salva, compila ed esegui il codice. Osservare l'output.

Passo 3) Decommenta le righe n. 6-9. Salva, compila ed esegui il codice. Osservare l'output.

Passo 4) Decommenta la riga n. 10 . Salva e compila il codice.

Passo 5) Errore = ? Questo perché la sottoclasse non può accedere ai membri privati ​​della superclasse.

Sintesi

• Il polimorfismo nella programmazione orientata agli oggetti si verifica quando ci sono una o più classi o oggetti legati tra loro per ereditarietà. È la capacità di un oggetto di assumere molte forme.
• Il metodo Overriding sta ridefinendo un metodo di superclasse in una sottoclasse.
• Polimorfismo dinamico in Java è il meccanismo mediante il quale è possibile definire più metodi con lo stesso nome e firma nella superclasse e nella sottoclasse.
• Polimorfismo statico in Java è un tipo di polimorfismo che raccoglie le informazioni per chiamare un metodo in fase di compilazione, mentre il polimorfismo dinamico è un tipo di polimorfismo che raccoglie le informazioni per chiamare un metodo in fase di esecuzione.
• La parola chiave Super può essere utilizzata per accedere ai metodi della classe padre dalla classe figlia.