Qual è la differenza tra polimorfismo dinamico e statico in Java?

• L'overloading del metodo sarebbe un esempio di polimorfismo statico

• Mentre l'override sarebbe un esempio di polimorfismo dinamico.

  Perché, in caso di sovraccarico, in fase di compilazione il compilatore sa quale metodo collegare alla chiamata. Tuttavia, è determinato in fase di esecuzione per il polimorfismo dinamico

Il polimorfismo dinamico (runtime) è il polimorfismo esistente in fase di esecuzione. Qui, il compilatore Java non capisce quale metodo viene chiamato al momento della compilazione. Solo JVM decide quale metodo viene chiamato in fase di esecuzione. L'overloading del metodo e l'override del metodo utilizzando i metodi di istanza sono gli esempi di polimorfismo dinamico.

Ad esempio,

• Si consideri un'applicazione che serializza e de-serializza diversi tipi di documento.

• Possiamo avere 'Document' come classe base e tipo di documento diverso classi derivanti da esso. Ad esempio XMLDocument, WordDocument, ecc.

• La classe Document definirà ’ Serialize () ' e ' De-serialize() ’ i metodi come virtuali e ogni classe derivata implementeranno questi metodi a suo modo in base al contenuto effettivo dei documenti.

• Quando diversi tipi di documenti devono essere serializzato / de-serializzato, gli oggetti del documento sarà indicato da il riferimento alla classe’ Document ' (o puntatore) e quando ‘ Il metodo Serialize() ’ o ‘ De-serialize() ’ viene chiamato su di esso, vengono chiamate versioni appropriate dei metodi virtuali.

Il polimorfismo statico (tempo di compilazione) è il polimorfismo esibito al momento della compilazione. Qui, il compilatore Java sa quale metodo viene chiamato. Overloading del metodo e override del metodo utilizzando metodi statici; override del metodo utilizzando metodi privati o finali sono esempi di statici polimorfismo

Ad esempio,

• Un oggetto employee può avere due metodi print() uno che prende no argomenti e uno che prende una stringa di prefisso da visualizzare insieme a i dati dei dipendenti.

• Date queste interfacce, quando il metodo print () viene chiamato senza alcun argomenti, il compilatore, guardando gli argomenti della funzione sa quale funzione è destinata ad essere chiamata e genera il codice oggetto conseguentemente.

Per maggiori dettagli si prega di leggere "Cos'è il polimorfismo" (Google it).

Polimorfismo: Il polimorfismo è la capacità di un oggetto di assumere molte forme. L'uso più comune del polimorfismo in OOP si verifica quando un riferimento di classe genitore viene utilizzato per fare riferimento a un oggetto di classe figlio.

Associazione dinamica/Polimorfismo runtime:

Polimorfismo del tempo di esecuzione noto anche come sovrascrittura del metodo. In questo meccanismo mediante il quale una chiamata a una funzione sovrascritta viene risolta in fase di esecuzione.

public class DynamicBindingTest {

    public static void main(String args[]) {
        Vehicle vehicle = new Car(); //here Type is vehicle but object will be Car
        vehicle.start();       //Car's start called because start() is overridden method
    }
}

class Vehicle {

    public void start() {
        System.out.println("Inside start method of Vehicle");
    }
}

class Car extends Vehicle {

    @Override
    public void start() {
        System.out.println("Inside start method of Car");
    }
}

Uscita:

Inizio interno metodo di Auto

Associazione statica /polimorfismo in fase di compilazione:

Quale metodo deve essere chiamato viene deciso solo in fase di compilazione.

public class StaticBindingTest {

    public static void main(String args[])  {
       Collection c = new HashSet();
       StaticBindingTest et = new StaticBindingTest();
       et.sort(c);

    }

    //overloaded method takes Collection argument
    public Collection sort(Collection c){
        System.out.println("Inside Collection sort method");
        return c;
    }


   //another overloaded method which takes HashSet argument which is sub class
    public Collection sort(HashSet hs){
        System.out.println("Inside HashSet sort method");
        return hs;
    }

}

Uscita: Inside Collection sort metho

Overloading del metodo è un esempio di compile time/static polymorphism poiché l'associazione del metodo tra la chiamata al metodo e la definizione del metodo avviene in fase di compilazione e dipende dal riferimento della classe(riferimento creato in fase di compilazione e va allo stack).

L'override del metodo è un esempio di run time/dynamic polymorphism poiché l'associazione del metodo tra la chiamata al metodo e la definizione del metodo avviene in fase di esecuzione e dipende dall'oggetto della classe (oggetto creato in fase di runtime e va all'heap) .

In termini semplici :

Polimorfismo statico : Lo stesso nome del metodo è sovraccarico con diverso tipo o numero di parametri in stessa classe (firma diversa). La chiamata al metodo mirato viene risolta in fase di compilazione.

Polimorfismo dinamico: Lo stesso metodo è sovrascritto con la stessa firma in classi diverse. Tipo di oggetto su quale metodo viene invocato non è noto in fase di compilazione, ma verrà deciso in fase di esecuzione.

Generalmente il sovraccarico non sarà considerato come polimorfismo.

Da java tutorial pagina :

Le sottoclassi di una classe possono definire i propri comportamenti univoci e tuttavia condividere alcune delle stesse funzionalità della classe genitore

L'associazione si riferisce al collegamento tra la chiamata al metodo e la definizione del metodo.

Questa immagine mostra chiaramente ciò che è vincolante.

In questa immagine, " a1.methodOne () "chiamata è vincolante alla corrispondente methodOne () definizione e" a1.methodTwo () " la chiamata è vincolante alla corrispondente definizione di methodTwo ().

Per ogni chiamata al metodo dovrebbe esserci una definizione corretta del metodo. Questa è una regola in java. Se il compilatore non vede il metodo corretto definizione per ogni chiamata al metodo, genera errore.

Ora, vieni a binding statico e binding dinamico in java.

Associazione statica in Java :

L'associazione statica è un'associazione che si verifica durante la compilazione. Lo è chiamato anche early binding perché il binding avviene prima di un programma esegue effettivamente

.

L'associazione statica può essere dimostrata come nell'immagine qui sotto.

In questa immagine ‘ ' a1 ' è un variabile di riferimento del tipo di classe A che punta all'oggetto della classe A. ‘a2 ' è anche variabile di riferimento del tipo di classe A ma che punta all'oggetto della classe B.

Durante la compilazione, durante l'associazione, il compilatore non controlla il tipo di oggetto a cui punta una particolare variabile di riferimento. Controlla semplicemente il tipo di variabile di riferimento attraverso la quale viene chiamato un metodo e controlla se esiste una definizione di metodo per esso in quel tipo.

Ad esempio, per " a1.method () " chiamata al metodo nell'immagine sopra, il compilatore controlla se esiste una definizione del metodo per method () in Classe A. Perché 'a1' è di tipo Classe A. Allo stesso modo, per " a2.method () " chiamata al metodo, controlla se esiste una definizione del metodo per method () in Classe A. Perché 'a2' è anche un tipo di classe A. Non controlla a quale oggetto, ‘a1’ e ‘a2’ stanno puntando. Questo tipo di associazione è chiamata associazione statica.

Associazione dinamica in Java :

L'associazione dinamica è un'associazione che succede durante il tempo di esecuzione. È anche chiamato binding tardivo perché il binding si verifica quando il programma è effettivamente esecuzione.

Durante il runtime gli oggetti effettivi vengono utilizzati per il binding. Ad esempio, per "a1.method () " chiama nell'immagine sopra, verrà chiamato method () dell'oggetto reale a cui punta ‘a1’. Per " a2.method () " call, il metodo () dell'oggetto reale a cui punta ‘a2’ verrà chiamato. Questo tipo di associazione è chiamata associazione dinamica.

Il legame dinamico di cui sopra l'esempio può essere dimostrato come di seguito.

Riferimento statico-binding-e-dinamico-binding-in-java

Polimorfismo statico: è dove la decisione di risolvere quale metodo da realizzare, è determinata durante il tempo di compilazione. L'overloading del metodo potrebbe essere un esempio di questo.

Polimorfismo dinamico: è dove viene impostata la decisione di scegliere quale metodo eseguire durante il runtime. L'override del metodo potrebbe essere un esempio di questo.

L'overloading del metodo è noto come Polimorfismo staticoe noto anche come Polimorfismo in fase di compilazioneo Associazione statica perché le chiamate al metodo sovraccaricate vengono risolte in fase di compilazione dal compilatore sulla base dell'elenco degli argomenti e del riferimento su cui stiamo chiamando il metodo.

E Il metodo che sostituisce è noto come Polimorfismo dinamico o semplice Polimorfismo o Metodo di runtime Dispatch o Dinamico Binding perché la chiamata al metodo sovrascritta viene risolta in fase di runtime.

Per capire perché questo è così prendiamo un esempio di Mammal eHuman classe

class Mammal {
    public void speak() { System.out.println("ohlllalalalalalaoaoaoa"); }
}

class Human extends Mammal {

    @Override
    public void speak() { System.out.println("Hello"); }

    public void speak(String language) {
        if (language.equals("Hindi")) System.out.println("Namaste");
        else System.out.println("Hello");
    }

}

Ho incluso l'output e il bytecode di sotto delle righe di codice

Mammal anyMammal = new Mammal();
anyMammal.speak();  // Output - ohlllalalalalalaoaoaoa
// 10: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V

Mammal humanMammal = new Human();
humanMammal.speak(); // Output - Hello
// 23: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V

Human human = new Human();
human.speak(); // Output - Hello
// 36: invokevirtual #7 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:()V

human.speak("Hindi"); // Output - Namaste
// 42: invokevirtual #9 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:(Ljava/lang/String;)V

E guardando il codice sopra possiamo vedere che i bytecode di humanMammal.parla (), umano.parlare () e umano.speak ("Hindi") sono totalmente diversi perché il compilatore è in grado di differenziarli in base all'argomento elenco e riferimento di classe. E questo è il motivo per cui Overloading del metodo è noto come Polimorfismo statico .

Ma bytecode per anyMammal.parlare () e humanMammal.speak () è lo stesso perché secondo il compilatore entrambi i metodi sono chiamati sul riferimento Mammal ma l'output per entrambe le chiamate al metodo è diverso perché in fase di runtime JVM sa quale oggetto contiene un riferimento e JVM chiama il metodo sull'oggetto e questo è il motivo per cui l'override del metodo è nota come Dinamica Polimorfismo.

Quindi dal codice sopra e bytecode, è chiaro che durante la fase di compilazione il metodo di chiamata è considerato dal tipo di riferimento. Ma al momento dell'esecuzione il metodo verrà chiamato dall'oggetto che il riferimento contiene.

Se vuoi saperne di più su questo puoi leggere di più su In che modo JVM gestisce il sovraccarico e l'override del metodo internamente.

Polimorfismo in fase di compilazione (Binding statico/Early Binding): Nel polimorfismo statico, se chiamiamo un metodo nel nostro codice, quale definizione di quel metodo deve essere chiamata in realtà viene risolta solo in fase di compilazione.

(o)

Al momento della compilazione, Java sa quale metodo richiamare controllando le firme del metodo. Quindi, questo è chiamato polimorfismo in fase di compilazione o legame statico.

Polimorfismo dinamico (Polimorfismo tardivo/ runtime): in fase di esecuzione, Java attende fino al runtime per determinare quale oggetto viene effettivamente puntato dal riferimento. La risoluzione del metodo è stata presa in fase di runtime, a causa di ciò che chiamiamo polimorfismo in fase di esecuzione.

L'overloading del metodo è un polimorfismo in fase di compilazione, facciamo un esempio per capire il concetto.

class Person                                            //person.java file
{
    public static void main ( String[] args )
    {
      Eat e = new Eat();
       e.eat(noodle);                                //line 6
    }

   void eat (Noodles n)      //Noodles is a object    line 8                     
   {

   }
   void eat ( Pizza p)           //Pizza is a object
  {

  }

}

In questo esempio, la persona ha un metodo eat che rappresenta che può mangiare Pizza o Noodles. Che il metodo eat sia sovraccarico quando compiliamo questa Persona.java il compilatore risolve la chiamata al metodo " e. eat (noodles) [che si trova alla riga 6] con la definizione del metodo specificata nella riga 8 ovvero il metodo che prende noodles come parametro e l'intero processo viene eseguito da Compilatore quindi è il polimorfismo del tempo di compilazione. Il processo di sostituzione della chiamata al metodo con la definizione del metodo viene chiamato come binding, in questo caso viene eseguito dal compilatore, quindi viene chiamato come binding iniziale.

Il polimorfismo si riferisce alla capacità di un oggetto di comportarsi in modo diverso per lo stesso trigger.

Polimorfismo statico (Polimorfismo in fase di compilazione)

• Il polimorfismo statico decide quale metodo eseguire durante la compilazione tempo.
• L'overloading del metodo è un esempio di polimorfismo statico, ed è requred a accade polimorfismo statico.
• Polimorfismo statico ottenuto attraverso il legame statico.
• Il polimorfismo statico avviene nello stesso classe.
• L'assegnazione di oggetti non è richiesta per il polimorfismo statico.
• Ereditarietà non coinvolta per il polimorfismo statico.

Polimorfismo dinamico (Polimorfismo runtime)

• Il polimorfismo dinamico decide quale metodo eseguire in runtime.
• L'override del metodo è un esempio di polimorfismo dinamico, ed è requred a accade polimorfismo dinamico.
• Polimorfismo dinamico ottenuto attraverso il legame dinamico.
• Dinamico Il polimorfismo avviene tra classi diverse.
• È necessario quando un oggetto sottoclasse viene assegnato alla super classe oggetto per polimorfismo dinamico.
• Ereditarietà coinvolta per il polimorfismo dinamico.