Qual è la differenza tra associazione anticipata e tardiva?

Question

Qual è la differenza tra associazione anticipata e tardiva?

Answer 1

La risposta breve è che l'associazione anticipata (o statica) si riferisce all'associazione in fase di compilazione e l'associazione tardiva (o dinamica) si riferisce all'associazione di runtime (ad esempio quando si utilizza la riflessione).

Answer 2

Nei linguaggi compilati, la differenza è netta.

Giava:

//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);

Nel primo esempio, il compilatore può fare ogni sorta di cose interessanti in fase di compilazione.Nella seconda bisogna solo sperare che chi utilizza il metodo lo faccia in modo responsabile.(Ovviamente, le JVM più recenti supportano il Class<? extends Foo> klass struttura, che può ridurre notevolmente questo rischio.)

Un altro vantaggio è che gli IDE possono collegarsi alla definizione della classe, poiché è dichiarata proprio nel metodo.La chiamata a create_something(Foo) potrebbe essere molto lontano dalla definizione del metodo e, se stai guardando la definizione del metodo, potrebbe essere bello vedere l'implementazione.

Il vantaggio principale dell'associazione tardiva è che rende più semplici cose come l'inversione del controllo, così come alcuni altri usi del polimorfismo e della tipizzazione duck (se la tua lingua supporta tali cose).

Answer 3

Tratto direttamente da http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Esistono due modi per utilizzare l'automazione (o OLE Automation) per controllare a livello di programmazione un'altra applicazione.

Late Binding utilizza CreateObject per creare e istanza dell'oggetto dell'applicazione, che è quindi possibile controllare.Ad esempio, per creare una nuova istanza di Excel usando l'associazione tardiva:

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

D'altra parte, per manipolare un'istanza esistente di Excel (se Excel è già aperto) useresti getObject (indipendentemente dal fatto che tu stia usando il legame precoce o tardivo):

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

Per utilizzare il binding precoce, è necessario prima impostare un riferimento nel progetto sull'applicazione che si desidera manipolare.Nell'editor VB di qualsiasi applicazione Office o nella stessa VB, lo fai selezionando strumenti + riferimenti e selezionando l'applicazione che desideri dall'elenco (EG“Libreria oggetti di Microsoft Excel 8.0”).

Per creare una nuova istanza di Excel utilizzando l'associazione anticipata:

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

In entrambi i casi, per inciso, puoi prima provare a ottenere un'istanza esistente di Excel e, se ciò restituisce un errore, è possibile creare una nuova istanza nel tuo gestore di errori.

Answer 4

Risposta simile ma più dettagliata dal libro Herbert Schildt C++: -

L'associazione anticipata si riferisce agli eventi che si verificano in fase di compilazione.In sostanza, l'associazione anticipata si verifica quando tutte le informazioni necessarie per chiamare una funzione sono note in fase di compilazione.(In altre parole, l'associazione anticipata significa che un oggetto e una chiamata di funzione vengono associati durante la compilazione.) Esempi di associazione anticipata includono chiamate di funzioni normali (incluse le funzioni della libreria standard), chiamate di funzioni sovraccaricate e operatori sovraccaricati.Il vantaggio principale dell'associazione anticipata è l'efficienza.Poiché tutte le informazioni necessarie per chiamare una funzione vengono determinate in fase di compilazione, questi tipi di chiamate di funzione sono molto veloci.

L'opposto dell'associazione anticipata è l'associazione tardiva.Il legame tardivo si riferisce alle chiamate di funzione che non vengono risolte fino al tempo di esecuzione.Le funzioni virtuali vengono utilizzate per ottenere l'associazione tardiva.Come sapete, quando l'accesso avviene tramite un puntatore o un riferimento base, la funzione virtuale effettivamente richiamata è determinata dal tipo di oggetto puntato dal puntatore.Poiché nella maggior parte dei casi ciò non può essere determinato in fase di compilazione, l'oggetto e la funzione non vengono collegati fino al momento dell'esecuzione.Il vantaggio principale della rilegatura tardiva è la flessibilità.A differenza del binding precoce, l'associazione tardiva consente di creare programmi in grado di rispondere agli eventi che si verificano mentre il programma esegue senza dover creare una grande quantità di "codice di contingenza". Tieni presente che, poiché una chiamata di funzione non viene risolta fino al tempo di esecuzione, l'associazione tardiva può rendere tempi di esecuzione un po 'più lenti.Tuttavia oggi i computer veloci hanno ridotto significativamente i tempi di esecuzione legati all'associazione tardiva.

Answer 5

Nelle lingue interpretate la differenza è un po’ più sottile.

Rubino:

# 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)

Poiché Ruby (generalmente) non è compilato, non esiste un compilatore che faccia le cose interessanti in anticipo.La crescita di JRuby significa che oggigiorno viene compilato più Ruby, facendolo agire più come Java, sopra.

Il problema con gli IDE è ancora valido:una piattaforma come Eclipse può cercare le definizioni delle classi se le codifichi in modo rigido, ma non può se le lasci al chiamante.

L'inversione del controllo non è molto popolare in Ruby, probabilmente a causa della sua estrema flessibilità di runtime, ma Rails fa un grande uso del late binding per ridurre la quantità di configurazione necessaria per far funzionare la tua applicazione.

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

Questo verrà stampato

adult1
child1

Nell'inizio del compilatore, il compilatore avrà accesso a tutti i metodi in Child and Teenager, ma in ritardo (in fase di esecuzione), verificherà i metodi che sono ignorati in esecuzione in fase di esecuzione.

Quindi il metodo1 (da Child - Early Binding) verrà sovrascritto dal metodo1 di Adult Intime (vincolo tardivo), implementerà Method1 da Child poiché non esiste un Method1 nel Method1 in Teenager.

Tieni presente che se il bambino non avesse un metodo1, il codice principale non verrebbe compilato.

Answer 7

Il polimorfismo in fase di compilazione chiamato anche sovraccarico o associazione anticipata o associazione statica quando abbiamo lo stesso nome di metodo con comportamenti diversi.Implementando il prototipo multiplo dello stesso metodo, in esso si verificano comportamenti diversi.Il collegamento anticipato si riferisce alla prima compilazione del programma.Ma nell'associazione tardiva l'oggetto viene eseguito in fase di esecuzione nel programma.Chiamato anche come legame dinamico o overriding o polimorfismo di runtime.