Quelle est la différence entre la liaison statique et la liaison dynamique?
Les temps de reliure peuvent être classés en deux types: statiques et dynamiques. Quelle est la différence entre la liaison statique et la liaison dynamique?
Pourriez-vous donner un exemple rapide de chacun pour mieux l'illustrer?
Dans les termes les plus généraux, liaison statique signifie que les références sont résolues au moment de la compilation .
Animal a = new Animal();
a.Roar(); // The compiler can resolve this method call statically.
liaison dynamique signifie que les références sont résolues lors de l'exécution .
public void MakeSomeNoise(object a) {
// Things happen...
((Animal) a).Roar(); // You won't know if this works until runtime!
}
Cela dépend du moment où la liaison se produit: au moment de la compilation (statique) ou au moment de l'exécution (dynamique). La liaison statique est utilisée lorsque vous appelez une méthode de classe simple. Lorsque vous commencez à traiter des hiérarchies de classes et des méthodes virtuelles, le compilateur commence à utiliser ce qu'on appelle VTABLE s. À ce moment, le compilateur ne sait pas exactement quelle méthode appeler et il doit attendre jusqu'à l'exécution pour trouver la bonne méthode à invoquer (cela se fait via VTABLE ). C'est ce qu'on appelle la liaison dynamique.
Voir l'article Wikipedia sur Tables virtuelles pour plus de détails et de références.
Je suis tombé sur cette réponse parfaite d'un utilisateur de quora "Monis Yousuf". Il l'explique parfaitement. Je le mets ici pour les autres.
La liaison est principalement un concept de programmation orientée objet lié au polymorphisme.
Tout d'abord, comprenez ce qu'est le polymorphisme . Les livres disent que cela signifie "un nom et plusieurs formes". C'est vrai, mais trop abstrait. Prenons un exemple concret. Vous allez chez un "Docteur", un médecin peut être ophtalmologiste, ORL, Neuro-Chirurgien, Homéopathe etc.
Ici, un "médecin" est un nom et peut avoir plusieurs types; chacun remplissant sa propre fonction. C'est du polymorphisme dans la vraie vie.
Surcharge de fonction: Ce concept décrit la liaison statique. La surcharge de fonctions peut être grossièrement définie comme, deux ou plusieurs méthodes (fonctions) qui ont le même nom mais des signatures différentes (y compris le nombre de paramètres, les types de paramètres, les types de retour différents) sont appelées méthodes (ou fonctions) surchargées.
Supposons que vous deviez calculer l'aire d'un rectangle et d'un cercle. Voir code ci-dessous: -
class CalculateArea {
private static final double PI = 3.14;
/*
Method to return area of a rectangle
Area of rectangle = length X width
*/
double Area(double length, double width) {
return (length * width);
}
/*
Method to return area of circle
Area of circle = π * r * r
*/
double Area(double radius) {
return PI * radius * radius;
}
}
Dans le code ci-dessus, il existe deux méthodes "Zone" avec des paramètres différents. Ce scénario est qualifié de surcharge de fonction.
Maintenant, venons-en à la vraie question: comment est cette liaison statique?
Lorsque vous appelez l'une des fonctions ci-dessus dans votre code, vous devez spécifier les paramètres que vous transmettez. Dans ce scénario, vous passerez soit:
- Deux paramètres de type double [qui appellera la première méthode, à calculer sont d'un rectangle]
- Paramètre unique de type double [qui appellera la deuxième méthode, pour calculer l'aire d'un cercle]
Puisque, au moment de la compilation, le compilateur Java peut déterminer quelle fonction appeler, il s'agit d'une liaison au moment de la compilation (ou STATIC).
Remplacement de fonction: Le remplacement de fonction est un concept qui est affiché dans l'héritage. Elle peut être grossièrement définie comme suit: lorsqu'une méthode est présente dans une classe parente et que sa sous-classe a également la même méthode avec la même signature, elle est appelée remplacement de fonction. [Il y a plus, mais pour des raisons de simplicité, j'ai écrit cette définition] Ce sera plus facile à comprendre avec le morceau de code ci-dessous.
class ParentClass {
int show() {
System.out.println("I am from parent class");
}
}
class ChildClass extends ParentClass{
int show() {
System.out.println("I am from child class");
}
}
class SomeOtherClass {
public static void main (String[] s) {
ParentClass obj = new ChildClass();
obj.show();
}
}
Dans le code ci-dessus, la méthode show() est remplacée car la même signature (et le même nom) est présente dans les classes parent et enfant.
Dans la troisième classe, SomeOtherClass, une variable de référence (obj) de type ParentClass contient l'objet de ChildClass. Ensuite, la méthode show() Est appelée à partir de la même variable de référence (obj).
Encore une fois, la même question: comment est cette liaison dynamique?
Au moment de la compilation, le compilateur vérifie que la variable Reference est de type ParentClass et vérifie si la méthode show() est présente dans cette classe. Une fois qu'il a vérifié cela, la compilation est réussie.
Maintenant, lorsque les programmes RUNS, il voit que l'objet est de ChildClass et par conséquent, il exécute la méthode show() de ChildClass. Étant donné que cette décision a lieu à RUNTIME, elle est appelée Liaison dynamique (ou polymorphisme d'exécution).
Lien pour la réponse originale
Liaison statique: est le processus de résolution des types, membres et opérations au moment de la compilation. Par exemple:
Car car = new Car();
car.Drive();
Dans cet exemple, le compilateur effectue la liaison en recherchant une méthode Drive sans paramètre sur l'objet car. Si n'a pas trouvé cette méthode! rechercher des méthodes prenant paramètres facultatifs , et si n'a pas trouvé à nouveau cette méthode rechercher classe de base de Car pour cette méthode, et si elle n'a pas trouvé cette méthode recherche à nouveau méthodes d'extension pour le type Car. Si aucune correspondance trouvée, vous obtiendrez l'erreur de compilation!
Dans ce cas, la liaison est effectuée par le compilateur, et la liaison dépend de la connaissance statique du type d'objet. Cela rend la liaison statique.
Liaison dynamique: la liaison dynamique diffère la liaison (processus de résolution des types, des membres et des opérations) de la compilation à runtime . Par exemple:
dynamic d = new Car();
d.Drive();
Un type dynamique indique au compilateur que nous nous attendons à ce que le type d'exécution de d ait la méthode Drive, mais nous pouvons ' t le prouver statiquement. Puisque le d est dynamique, le compilateur reporte la liaison de Drive à d jusqu'à l'exécution.
La liaison dynamique est utile dans les cas où, au moment de la compilation, nous savons qu'une certaine fonction, membre de l'opération existe, mais que le compilateur ne savait pas! Cela se produit généralement lorsque nous interopérons avec langages de programmation dynamiques, [~ # ~] com [~ # ~] et réflexion.