Care este diferența dintre legarea timpurie și târzie?

Taken directly from http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Există două moduri de a utiliza Automatizarea (sau automatizarea OLE)   controlați în mod programatic o altă aplicație.

     

Legarea târzie utilizează CreateObject pentru a crea și instanța   obiect de aplicație, pe care apoi îl puteți controla. De exemplu, pentru a crea   o nouă instanță a programului Excel folosind legarea târzie:

  Dim oXL ca obiect
 Setați oXL = CreateObject ("Excel.Application")
 

     

Pe de altă parte, pentru a manipula o instanță existentă din Excel (dacă   Excel este deja deschis) ați utiliza GetObject (indiferent dacă   utilizați obligatoriu devreme sau târziu):

  Dim oXL ca obiect
 Setați oXL = GetObject ("Excel.Application")
 

     

Pentru a utiliza legarea timpurie, trebuie mai întâi să setați o referință în secțiunea dvs.   proiect la aplicația pe care doriți să o manipulați. În editorul VB al   orice aplicație Office sau chiar în VB faceți acest lucru selectând   Instrumente + Referințe și selectarea aplicației dorite de la   listă (de exemplu,? Microsoft Excel 8.0 Object Library?).

     

Pentru a crea o nouă instanță a aplicației Excel utilizând legarea timpurie:

  Dim oXL Ca Excel.Application
 Setați oXL = Noua aplicație Excel.Application
 

     

În ambele cazuri, întâmplător, puteți încerca mai întâi să obțineți un existent   Exemplu de Excel și dacă aceasta returnează o eroare, puteți crea un nou   instanță în dispozitivul de eroare.

În limbile compilate, diferența este strictă.

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

In the first example, the compiler can do all sorts of neat stuff at compile time. In the second, you just have to hope that whoever uses the method does so responsibly. (Of course, newer JVMs support the Class klass structure, which can greatly reduce this risk.)

Un alt avantaj este că IDE-urile se pot conecta la definiția clasei, deoarece sunt declarate chiar acolo în metodă. Apelul de a crea_something (Foo) ar putea fi foarte departe de definiția metodei și dacă vă uitați la definiția metodei, ar fi bine să vedeți implementarea.

Avantajul major al legării târzii este că facilitează inversarea controlului, precum și anumite alte utilizări ale polimorfismului și tipărirea rațelor (dacă limba dvs. susține astfel de lucruri).

În limbile interpretate, diferența este puțin mai subtilă.

Rubin:

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

Deoarece Ruby este (în general) nu compilat, nu există un compilator pentru a face lucrurile de nișă up-front. Creșterea lui JRuby înseamnă că mai mult Ruby este compilat în aceste zile, deși, făcând să acționeze mai mult ca Java, de mai sus.

Problema cu IDE rămâne: o platformă ca Eclipse poate căuta definiții de clasă dacă le codificați cu greu, dar nu le puteți lăsa la apelant.

Inversiunea de control nu este extrem de populară în Ruby, probabil din cauza flexibilității extreme a runtime-ului, dar Rails folosește foarte mult legarea târzie pentru a reduce cantitatea de configurație necesară pentru a vă face aplicația.

Răspunsul scurt este că legarea timpurie (sau statică) se referă la legarea timpului de compilare, iar legarea târzie (sau dinamică) se referă la legarea de rulare (de exemplu atunci când utilizați reflexia).

Un răspuns similar, dar mai detaliat, din cartea lui Herbert Schildt C ++:

Legarea timpurie se referă la evenimente care apar la momentul compilării. În esență, legarea timpurie apare atunci când toate informațiile necesare pentru a apela o funcție sunt cunoscute la momentul compilării. (Puneți diferit, legarea rapidă înseamnă că un obiect și un apel de funcție sunt legate în timpul compilării.) Exemple de legare rapidă includ apelurile de funcții normale (inclusiv funcțiile standard ale bibliotecii), apelurile de funcții supraîncărcate și operatorii supraîncărcați. Principalul avantaj al legării rapide este eficiența. Deoarece toate informațiile necesare pentru a apela o funcție sunt determinate la timpul de compilare, aceste tipuri de apeluri pentru funcții sunt foarte rapide.

Opusul legării timpurii este întârzierea legării. Întârzierea legării se referă pentru a efectua apeluri care nu sunt rezolvate până la ora de rulare. Funcțiile virtuale sunt folosite pentru a realiza legarea târzie. După cum știți, atunci când accesul se face printr-un pointer de bază sau o referință, funcția virtuală numită de fapt este determinată de tipul de obiect indicat de pointer. Deoarece în majoritatea cazurilor acest lucru nu poate fi determinat la timpul de compilare, obiectul și funcția nu sunt legate până la timpul de execuție. Principalul avantaj al legării târzii este flexibilitatea. Spre deosebire de legarea timpurie, legarea târzie vă permite să creați programe care pot răspunde evenimentelor care apar în timp ce programul se execută fără a trebui să creați un cantitate mare de "cod de urgență." Rețineți că, deoarece un apel pentru funcții nu este rezolvat până la timpul de execuție, legarea târzie poate face timpi de execuție mai mici. Totuși, astăzi, computerele rapide au redus în mod semnificativ timpul de execuție legat de legarea târzie.

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

Aceasta va fi imprimată

adult1
child1

În legarea timpurie compilatorul va avea acces la toate metodele la copil și la adolescent dar în întârziere obligatorie (la runtime), va verifica metodele care sunt suprasolicitate la timpul de execuție.

Prin urmare, metoda1 (de la legarea copilului - timpuriu) va fi suprascrisă de metoda1 de la adult la timpul de execuție (legarea târzie) Apoi va implementa metoda1 de la copil, deoarece nu există nici o metodă1 în metoda1 în adolescent.

Rețineți că dacă copilul nu avea o metodă1, atunci codul principal nu s-ar compila.

Polimorfismul de compilare a timpului numit de asemenea ca legare la supraîncărcare sau legare timpurie sau legare statică atunci când avem același nume de metodă cu comportamente diferite. Prin implementarea prototipului multiplu al aceleiași metode și comportamentul diferit are loc în el. Legarea anterioară se referă la prima compilare a programului. Dar, în obiectul oblic întârziat, timpul de execuție apare în program. De asemenea, numit ca legare dinamică sau polimorfism de durată sau durată de execuție.