Vs statique Liaison dynamic en Java

Je suis en train de faire un devoir pour l’une de mes classes, et je dois lui donner des exemples, en utilisant la syntaxe Java, de la liaison statique et dynamic .

Je comprends le concept de base, à savoir que la liaison statique se produit au moment de la compilation et que la liaison dynamic se produit au moment de l’exécution, mais je n’arrive pas à comprendre comment elle fonctionne réellement.

J’ai trouvé un exemple de liaison statique en ligne qui donne cet exemple:

public static void callEat(Animal animal) { System.out.println("Animal is eating"); } public static void callEat(Dog dog) { System.out.println("Dog is eating"); } public static void main(Ssortingng args[]) { Animal a = new Dog(); callEat(a); } 

Et que cela imprimerait “animal mange” parce que l’appel à callEat utilise une liaison statique , mais je ne suis pas sûr de savoir pourquoi cela est considéré comme une liaison statique.

Jusqu’à présent, aucune des sources que j’ai vues n’a réussi à l’expliquer d’une manière que je peux suivre.

Extrait du blog Javarevisited :

Voici quelques différences importantes entre la liaison statique et la liaison dynamic:

  1. La liaison statique en Java se produit pendant la compilation, tandis que la liaison dynamic se produit pendant l’exécution.
  2. private méthodes et variables private , final et static utilisent la liaison statique et sont liées par le compilateur alors que les méthodes virtuelles sont liées lors de l’exécution en fonction de l’object d’exécution.
  3. La liaison statique utilise les informations Type ( class in Java) pour la liaison, tandis que la liaison dynamic utilise l’object pour résoudre la liaison.
  4. Les méthodes surchargées sont liées à l’aide d’une liaison statique, tandis que les méthodes surchargées sont liées à l’aide d’une liaison dynamic à l’exécution.

Voici un exemple qui vous aidera à comprendre les liaisons statiques et dynamics en Java.

Exemple de liaison statique en Java

 public class StaticBindingTest { public static void main(Ssortingng 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 : méthode de sorting à l’intérieur de la collection

Exemple de liaison dynamic en Java

 public class DynamicBindingTest { public static void main(Ssortingng 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: Méthode de démarrage interne de la voiture

La connexion d’un appel de méthode au corps de la méthode est appelée liaison. Comme le disait Maulik, “la liaison statique utilise les informations Type (Class in Java) pour la liaison, alors que la liaison dynamic utilise Object pour résoudre la liaison.” Donc ce code:

 public class Animal { void eat() { System.out.println("animal is eating..."); } } class Dog extends Animal { public static void main(Ssortingng args[]) { Animal a = new Dog(); a.eat(); // prints >> dog is eating... } @Override void eat() { System.out.println("dog is eating..."); } } 

Produira le résultat: chien mange … parce qu’il utilise la référence d’object pour trouver la méthode à utiliser. Si nous changeons le code ci-dessus en ceci:

 class Animal { static void eat() { System.out.println("animal is eating..."); } } class Dog extends Animal { public static void main(Ssortingng args[]) { Animal a = new Dog(); a.eat(); // prints >> animal is eating... } static void eat() { System.out.println("dog is eating..."); } } 

Cela produira: l’ animal mange … parce que c’est une méthode statique, il faut donc utiliser Type (dans ce cas, Animal) pour déterminer quelle méthode statique appeler. Outre les méthodes statiques, les méthodes privées et finales utilisent la même approche.

Le compilateur sait seulement que le type de “a” est Animal ; cela se produit au moment de la compilation, à cause de quoi il est appelé liaison statique (surcharge de méthode). Mais s’il s’agit d’une liaison dynamic, alors il appellerait la méthode de la classe Dog . Voici un exemple de liaison dynamic.

 public class DynamicBindingTest { public static void main(Ssortingng args[]) { Animal a= new Dog(); //here Type is Animal but object will be Dog a.eat(); //Dog's eat called because eat() is overridden method } } class Animal { public void eat() { System.out.println("Inside eat method of Animal"); } } class Dog extends Animal { @Override public void eat() { System.out.println("Inside eat method of Dog"); } } 

Sortie: méthode de manger à l’intérieur du chien

Il existe trois différences majeures entre la liaison statique et la liaison dynamic lors de la conception des compilateurs et la manière dont les variables et les procédures sont transférées dans l’environnement d’ exécution . Ces différences sont les suivantes:

Liaison statique : Dans la liaison statique, trois problèmes suivants sont abordés:

  • Définition d’une procédure

  • Déclaration d’un nom (variable, etc.)

  • Portée de la déclaration

Liaison dynamic : trois problèmes rencontrés dans la liaison dynamic sont les suivants:

  • Activation d’une procédure

  • Reliure d’un nom

  • Durée de vie d’une reliure

Avec la méthode statique dans la classe parent et enfant: Liaison statique

 public class test1 { public static void main(Ssortingng args[]) { parent pc = new child(); pc.start(); } } class parent { static public void start() { System.out.println("Inside start method of parent"); } } class child extends parent { static public void start() { System.out.println("Inside start method of child"); } } // Output => Inside start method of parent 

Reliure dynamic:

 public class test1 { public static void main(Ssortingng args[]) { parent pc = new child(); pc.start(); } } class parent { public void start() { System.out.println("Inside start method of parent"); } } class child extends parent { public void start() { System.out.println("Inside start method of child"); } } // Output => Inside start method of child 

Parce que le compilateur connaît la liaison au moment de la compilation. Si vous invoquez une méthode sur une interface, par exemple, le compilateur ne peut pas le savoir et la liaison est résolue à l’exécution, car l’object réel ayant une méthode invoquée peut être l’un des nombreux. Par conséquent, il s’agit d’une liaison d’exécution ou dynamic.

Votre appel est lié à la classe Animal au moment de la compilation car vous avez spécifié le type. Si vous avez passé cette variable à une autre méthode ailleurs, personne ne saurait (à part vous parce que vous l’avez écrit) quelle classe elle serait réellement. Le seul indice est le type déclaré d’Animal.