Quelle est la différence entre une liaison anticipée et tardive ?

Question

Quelle est la différence entre une liaison anticipée et tardive ?

Answer 1

La réponse courte est que la liaison précoce (ou statique) fait référence à la liaison au moment de la compilation et la liaison tardive (ou dynamique) fait référence à la liaison à l'exécution (par exemple lorsque vous utilisez la réflexion).

Answer 2

Dans les langages compilés, la différence est frappante.

Java:

//early binding:
public create_a_foo(*args) {
 return new Foo(args)
}
my_foo = create_a_foo();

//late binding:
public create_something(Class klass, *args) {
  klass.new_instance(args)
}
my_foo = create_something(Foo);

Dans le premier exemple, le compilateur peut faire toutes sortes de choses intéressantes au moment de la compilation.Dans le second cas, il suffit d’espérer que celui qui utilise la méthode le fasse de manière responsable.(Bien sûr, les JVM les plus récentes prennent en charge le Class<? extends Foo> klass structure, ce qui peut réduire considérablement ce risque.)

Un autre avantage est que les IDE peuvent créer un lien direct vers la définition de classe, car elle est déclarée directement dans la méthode.L'appel à create_something(Foo) pourrait être très loin de la définition de la méthode, et si vous regardez la définition de la méthode, ce serait peut-être bien de voir l'implémentation.

Le principal avantage de la liaison tardive est qu'elle facilite des choses comme l'inversion de contrôle, ainsi que certaines autres utilisations du polymorphisme et du typage canard (si votre langage prend en charge de telles choses).

Answer 3

Tiré directement de http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Il existe deux façons d'utiliser l'automatisation (ou l'automatisation OLE) pour contrôler par programme une autre application.

La liaison tardive utilise CreateObject pour créer et instance de l'objet d'application, que vous pouvez ensuite contrôler.Par exemple, pour créer une nouvelle instance d'Excel en utilisant la liaison tardive:

 Dim oXL As Object
 Set oXL = CreateObject("Excel.Application")

D'un autre côté, pour manipuler une instance existante d'Excel (si Excel est déjà ouvert), vous utiliseriez GetObject (que vous utilisiez la liaison précoce ou tardive):

 Dim oXL As Object
 Set oXL = GetObject(, "Excel.Application")

Pour utiliser la liaison précoce, vous devez d'abord définir une référence dans votre projet sur l'application que vous souhaitez manipuler.Dans l'éditeur VB de toute application Office, ou dans VB lui-même, vous le faites en sélectionnant des outils + références et en sélectionnant l'application que vous souhaitez dans la liste (par exemple"Bibliothèque d'objets Microsoft Excel 8.0").

Pour créer une nouvelle instance d'Excel à l'aide de la liaison anticipée :

 Dim oXL As Excel.Application
 Set oXL = New Excel.Application

Dans les deux cas, d'ailleurs, vous pouvez d'abord essayer d'obtenir une instance existante d'Excel, et si cela renvoie une erreur, vous pouvez créer une nouvelle instance dans votre gestionnaire d'erreurs.

Answer 4

Réponse similaire mais plus détaillée du livre Herbert Schildt C++ : -

La liaison anticipée fait référence aux événements qui se produisent au moment de la compilation.Essentiellement, une liaison précoce se produit lorsque toutes les informations nécessaires pour appeler une fonction sont connues au moment de la compilation.(En d'autres termes, la liaison anticipée signifie qu'un objet et un appel de fonction sont liés lors de la compilation.) Des exemples de liaison anticipée incluent les appels de fonction normaux (y compris les fonctions de bibliothèque standard), les appels de fonction surchargés et les opérateurs surchargés.Le principal avantage de la liaison anticipée est l’efficacité.Étant donné que toutes les informations nécessaires pour appeler une fonction sont déterminées au moment de la compilation, ces types d'appels de fonction sont très rapides.

Le contraire de la liaison anticipée est la liaison tardive.La liaison tardive fait référence aux appels de fonction qui ne sont résolus qu'au temps d'exécution.Les fonctions virtuelles sont utilisées pour réaliser une liaison tardive.Comme vous le savez, lorsque l'accès se fait via un pointeur de base ou une référence, la fonction virtuelle effectivement appelée est déterminée par le type d'objet pointé par le pointeur.Étant donné que dans la plupart des cas, cela ne peut pas être déterminé au moment de la compilation, l'objet et la fonction ne sont liés qu'au moment de l'exécution.Le principal avantage de la liaison tardive est la flexibilité.Contrairement à la liaison précoce, la liaison tardive vous permet de créer des programmes qui peuvent répondre aux événements qui se produisent pendant que le programme s'exécute sans avoir à créer une grande quantité de «code de contingence». Gardez à l'esprit que parce qu'un appel de fonction n'est résolu qu'au temps d'exécution, la liaison tardive peut rendre les temps d'exécution un peu plus lents.Mais aujourd’hui, les ordinateurs rapides ont considérablement réduit les temps d’exécution liés aux liaisons tardives.

Answer 5

Dans les langues interprétées, la différence est un peu plus subtile.

Rubis:

# early binding:
def create_a_foo(*args)
  Foo.new(*args)
end
my_foo = create_a_foo

# late binding:
def create_something(klass, *args)
  klass.new(*args)
end
my_foo = create_something(Foo)

Étant donné que Ruby n'est (généralement) pas compilé, il n'existe pas de compilateur pour effectuer les tâches astucieuses initiales.La croissance de JRuby signifie que davantage de Ruby est compilé de nos jours, ce qui le fait agir davantage comme Java ci-dessus.

Le problème avec les IDE persiste :une plate-forme comme Eclipse peut rechercher des définitions de classe si vous les codez en dur, mais ne le peut pas si vous les laissez à l'appelant.

L'inversion de contrôle n'est pas très populaire dans Ruby, probablement en raison de son extrême flexibilité d'exécution, mais Rails fait un grand usage de la liaison tardive pour réduire la quantité de configuration nécessaire au fonctionnement de votre application.

Answer 6

public class child()
{    public void method1()
     {     System.out.println("child1");
     }
    public void method2()
     {     System.out.println("child2");
     }

}
public class teenager extends child()
{    public void method3()
     {      System.out.println("teenager3");
     }
}
public class adult extends teenager()
{     
    public void method1()
    {    System.out.println("adult1);
         super.method1();
     }
}


//In java
public static void main(String []args)
{    ((teenager)var).method1();
}

Cela s'imprimera

adult1
child1

Dans la liaison précoce, le compilateur aura accès à toutes les méthodes de l'enfant et de l'adolescent, mais en liaison tardive (au moment de l'exécution), il vérifiera les méthodes qui sont remplacées au moment de l'exécution.

Par conséquent, la méthode1 (de l'enfant - la liaison précoce) sera remplacée par la méthode1 de l'adulte à l'exécution (liaison tardive), il implémentera la méthode1 de l'enfant car il n'y a pas de méthode1 dans la méthode1 chez l'adolescent.

Notez que si child n'avait pas de méthode1, le code principal ne serait pas compilé.

Answer 7

Le polymorphisme au moment de la compilation est également appelé surcharge ou liaison précoce ou liaison statique lorsque nous avons le même nom de méthode avec des comportements différents.En implémentant le prototype multiple de la même méthode, un comportement différent s'y produit.La liaison anticipée fait référence à la première compilation du programme.Mais en cas de liaison tardive, l'exécution de l'objet se produit dans le programme.Également appelé liaison dynamique ou remplacement ou polymorphisme d'exécution.