Quelle est la différence entre le polymorphisme dynamique et statique en Java?

• La surcharge de Méthode serait un exemple de polymorphisme statique

• Alors que la substitution serait un exemple de polymorphisme dynamique.

  Car, en cas de surcharge, au moment de la compilation, le compilateur sait quelle méthode lier à l'appel. Cependant, il est déterminé à l'exécution pour le polymorphisme dynamique

Dynamique (temps d'exécution) polymorphisme est le polymorphisme existait au moment de l'exécution. Ici, le compilateur Java ne comprend pas quelle méthode est appelée au moment de la compilation. Seule la JVM décide quelle méthode est appelée au moment de l'exécution. La surcharge de méthode et la substitution de méthode à l'aide de méthodes d'instance sont des exemples de polymorphisme dynamique.

Par exemple,

• Considérons une application qui sérialise et désérialise différents types de document.

• Nous pouvons avoir ‘Document ' comme classe de base et type de document différent les classes qui en découlent. Par exemple , XMLDocument , WordDocument, etc.

• La classe Document définira ‘ Serialize() ’ et ‘ De-serialize() ’ les méthodes en tant que virtual et chaque classe dérivée les implémenteront méthodes à sa manière sur la base du contenu réel des documents.

• Lorsque différents types de documents doivent être sérialisés/désérialisés, les objets document seront visés par la référence de classe 'Document' (ou pointeur) et lorsque le ‘ La méthode Serialize() ’ ou ‘ De-serialize() ’ est appelée dessus, versions appropriées des méthodes virtuelles sont appelés.

Statique (compilation) polymorphisme est le polymorphisme présentaient au moment de la compilation. Ici, le compilateur Java sait quelle méthode est appelée. La surcharge de méthode et la substitution de méthode à l'aide de méthodes statiques; la substitution de méthode à l'aide de méthodes privées ou finales sont des exemples de méthodes statiques polymorphisme

Par exemple,

• Un objet employé peut avoir deux méthodes print () l'une prenant no arguments et un prenant une chaîne de préfixe à afficher avec les données de l'employé.

• Étant donné ces interfaces, lorsque la méthode print () est appelée sans aucune arguments, le compilateur, en regardant les arguments de la fonction sait quelle fonction est destinée à être appelée et il génère le code objet conséquent.

Pour plus de détails veuillez lire "Qu'est-ce que le polymorphisme" (Google it).

Polymorphisme: Le polymorphisme est la capacité d'un objet à prendre de nombreuses formes. L'utilisation la plus courante du polymorphisme dans la POO se produit lorsqu'une référence de classe parent est utilisée pour faire référence à un objet de classe enfant.

Liaison Dynamique/Polymorphisme D'Exécution :

Polymorphisme de temps d'exécution également connu sous le nom de méthode de remplacement. Dans ce mécanisme par lequel un appel à une fonction surchargée est résolu à un moment d'exécution.

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

Sortie:

Début intérieur méthode de voiture

Liaison statique /polymorphisme au moment de la compilation:

La méthode à appeler n'est décidée qu'au moment de la compilation.

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

}

Sortie: À l'intérieur de la collection trier metho

La surcharge de méthode est un exemple de compile time/static polymorphism parce que la liaison de méthode entre l'appel de méthode et la définition de méthode se produit au moment de la compilation et cela dépend de la référence de la classe(référence créée au moment de la compilation et va à la pile).

Le remplacement de la méthode {[6] } est un exemple de run time/dynamic polymorphism parce que la liaison de méthode entre l'appel de méthode et la définition de méthode se produit au moment de l'exécution et cela dépend de l'objet de la classe (objet créé au moment de l'exécution et va au tas) .

En termes simples :

polymorphisme Statique : Même le nom de la méthode est surchargé avec le type ou le nombre de paramètres dans même la classe (signature différente). L'appel de méthode ciblé est résolu au moment de la compilation.

Dynamique polymorphisme: la Même méthode est remplacé avec la même signature dans les différentes classes. Type d'objet sur quelle méthode est invoquée n'est pas connu au moment de la compilation, mais sera décidé au moment de l'exécution.

Généralement, la surcharge ne sera pas considérée comme un polymorphisme.

À Partir de java tutoriel page :

Sous-classes d'une classe peuvent définir leurs propres comportements et pourtant, partagent les mêmes fonctionnalités de la classe parent

Binding fait référence au lien entre l'appel de méthode et la définition de méthode.

Cette image montre clairement ce qui est contraignant.

Dans cette image, "a1.methodOne () "l'appel se lie à la définition methodOne () correspondante et à" a1.L'appel methodTwo () " est lié à la définition methodTwo () correspondante.

Pour chaque appel de méthode, il devrait y avoir une définition de méthode appropriée. C'est une règle en java. Si le compilateur ne voit pas la méthode appropriée définition pour chaque appel de méthode, il génère une erreur.

Maintenant, venez à la liaison statique et à la liaison dynamique en java.

Liaison Statique En Java:

La liaison statique est une liaison qui se produit pendant la compilation. Il est aussi appelé liaison précoce car la liaison se produit avant un programme fonctionne en fait

.

La liaison statique peut être démontrée comme dans l'image ci-dessous.

, Dans cette image, " a1 " est un variable de référence de la classe de type A pointant vers l'objet de la classe A. ‘a2 ' est également une variable de référence de la classe de type A mais pointant vers l'objet de la classe B.

Pendant la compilation, lors de la liaison, le compilateur ne vérifie pas le type d'objet vers lequel une variable de référence particulière pointe. Il vérifie simplement le type de variable de référence à travers lequel une méthode est appelée et vérifie s'il existe une définition de méthode pour elle dans ce type.

Par exemple, pour "a1.méthode () " appel de méthode dans l'image ci-dessus, le compilateur vérifie s'il existe une définition de méthode pour method() dans la classe A. Parce que 'a1' est un type de classe A. De même, pour " a2.method () " appel de méthode, il vérifie s'il existe une définition de méthode pour method () dans la classe A. Parce que 'a2' est également un type de classe A. Il ne vérifie pas vers quel objet,’ a1 ‘et’ a2 ' pointent. Ce type de liaison est appelé liaison statique.

Liaison Dynamique En Java :

La liaison dynamique est une liaison qui se produit lors de l'exécution. Il est également appelé liaison tardive car la liaison se produit lorsque le programme est réellement exécuter.

Pendant l'exécution, les objets réels sont utilisés pour la liaison. Par exemple, pour "a1.method () " appel dans l'image ci-dessus, method() de l'objet réel vers lequel ‘a1’ pointe sera appelé. Pour " a2.method () " call, method () de l'objet réel vers lequel ‘a2’ pointe sera appelé. Ce type de liaison est appelé liaison dynamique.

La liaison dynamique de ci-dessus exemple peut être démontré comme ci-dessous.

Référence statique de la liaison et de la dynamique de la liaison-en-java

Polymorphisme statique: est l'endroit où la décision de résoudre la méthode à accomplir est déterminée pendant la compilation. La surcharge de méthode pourrait en être un exemple.

Polymorphisme dynamique: est l'endroit où la décision de choisir la méthode à exécuter est définie pendant l'exécution. La substitution de méthode pourrait en être un exemple.

La surcharge de méthode est connue sous le nom de Polymorphisme statiqueet également connue sous le nom de Polymorphisme de compilationou Liaison statique car les appels de méthode surchargés sont résolus au moment de la compilation par le compilateur sur la base de la liste d'arguments et de la référence

Et redéfinition de Méthode est connu comme Dynamique Polymorphisme ou simple Polymorphisme ou Exécution de la Méthode d'Expédition ou Dynamique Binding car l'appel de méthode surchargé est résolu au moment de l'exécution.

Pour comprendre pourquoi il en est ainsi prenons un exemple de Mammal et de Human class

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

}

J'ai inclus la sortie ainsi que le bytecode des lignes de code ci-dessous

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

Et en regardant le code ci-dessus, nous pouvons voir que les bytecodes de humanMammal.parler() , de l'homme.parler() et de l'homme.speak ("Hindi") sont totalement différents car le compilateur est capable de les différencier en fonction de l'argument liste et référence de classe. Et c'est pourquoi la surcharge de la méthode est connue sous le nom de Polymorphisme statique.

Mais bytecode pour anyMammal.parler () et humanMammal.speak () est le même car selon le compilateur, les deux méthodes sont appelées sur la référence Mammal mais la sortie pour les deux appels de méthode est différente car au moment de l'exécution, la JVM sait quel objet une référence contient et la JVM appelle la méthode sur l'objet. Polymorphisme.

Donc, à partir du code et du bytecode ci-dessus, il est clair que pendant la phase de compilation, la méthode d'appel est considérée à partir du type de référence. Mais au moment de l'exécution, la méthode sera appelée à partir de l'objet que la référence contient.

Si vous voulez en savoir plus à ce sujet, vous pouvez en savoir plus sur Comment la JVM Gère-t-elle la surcharge et le remplacement des méthodes en interne.

Polymorphisme au moment de la compilation(Liaison statique/Liaison précoce): Dans le polymorphisme statique, si nous appelons une méthode dans notre code, la définition de cette méthode à appeler n'est résolue qu'au moment de la compilation.

(ou)

Au moment de la compilation, Java sait quelle méthode invoquer en vérifiant les signatures de la méthode. Donc, c'est ce qu'on appelle le polymorphisme au moment de la compilation ou la liaison statique.

Dynamique Polymorphisme(Liaison Tardive/ Polymorphisme d'Exécution): Au moment de l'exécution, Java attend jusqu'à l'exécution pour déterminer quel objet est réellement pointé par la référence. La résolution de la méthode a été prise lors de l'exécution, en raison de ce que nous appelons polymorphisme d'exécution.

La surcharge de méthode est un polymorphisme au moment de la compilation, prenons un exemple pour comprendre le concept.

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
  {

  }

}

Dans cet exemple, la personne a une méthode eat qui représente qu'elle peut manger de la Pizza ou des nouilles. Que la méthode eat est surchargée lorsque nous compilons cette personne.java le compilateur résout l'appel de méthode " e. eat (noodles) [qui est à la ligne 6] avec la définition de méthode spécifiée à la ligne 8, c'est-à-dire la méthode qui prend noodles comme paramètre et l'ensemble du processus est effectué par Compilateur c'est donc un polymorphisme au moment de la compilation. Le processus de remplacement de l'appel de méthode par la définition de méthode est appelé comme liaison, dans ce cas, il est fait par le compilateur donc il est appelé comme liaison précoce.

Le polymorphisme fait référence à la capacité d'un objet à se comporter différemment pour le même déclencheur.

Polymorphisme statique (Polymorphisme à la compilation)

• Le polymorphisme statique décide quelle méthode exécuter pendant la compilation temps.
• La surcharge de méthode est un exemple de polymorphisme statique, et c'est requred à arrive polymorphisme statique.
• Polymorphisme statique obtenu par liaison statique.
• Le polymorphisme statique se produit dans le même classe.
• L'affectation d'objet n'est pas requise pour le polymorphisme statique.
• Héritage non impliqué pour le polymorphisme statique.

Dynamique Polymorphisme (Polymorphisme D'Exécution)

• Le polymorphisme dynamique décide de la méthode à exécuter lors de l'exécution.
• Le remplacement de la méthode est un exemple de polymorphisme dynamique, et il est requred à arrive polymorphisme dynamique.
• Polymorphisme dynamique obtenu par liaison dynamique.
• Dynamique Le polymorphisme se produit entre différentes classes.
• Il est requis lorsqu'un objet de sous-classe est affecté à la super classe objet pour polymorphisme dynamique.
• Héritage impliqué pour le polymorphisme dynamique.