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

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

0
fr hi bn
adăugat autor jfs, sursa
Duplicat posibil din Legarea timpurie și târzie
adăugat autor berkay, sursa
Ar fi greșit să spun devreme = apel direct funcție în timp ce târziu = apel pentru a funcționa printr-un indicator pointer? Nu încet niciodată să mă uimească cum programatorii au un mod de a lua concepte simple și de a le face să pară mult mai complexe decât sunt (ca un spectacol de inteligență?). Programarea este în mod inerent un domeniu foarte ușor de studiu până când ajungeți la lucruri cum ar fi modul în care se face un tip de flotor sau dezvoltarea compilatoarelor.
adăugat autor Bob Blogge, sursa

7 răspunsuri

Î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<? extends Foo> 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).

0
adăugat

Î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.

0
adăugat
Acest punct se aplică și limbilor compilate care pot include componente compilate JIT și incluse în timpul rulării pentru implementarea pluginurilor sau cadrelor dinamice. Unele exemple canonice de acest lucru există în Java, și, desigur, ruby și Python. Un exemplu extrem este Erlang, unde runtime-ul poate încărca simultan două versiuni ale unui modul pentru actualizări/downgrades live. Deci, deși o mulțime de cod Erlang (majoritatea?) Este scrisă ca funcții pure tipărite static, cerințele de execuție mandatează întârzierea legării și tipurile dinamice sub capotă.
adăugat autor zxq9, sursa

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.

0
adăugat
Știu că răspunsul ăsta este vechi și că provine din altă parte, dar nu este exact. Întârzierea obligatorie presupune utilizarea lui CreateObject, dar CreateObject nu implică neapărat legarea târzie. Legarea nu se aplică metodei de instanțiere a unui obiect, ci numai modului în care acesta este declarat. Dacă declarați obiectul "Ca Excel.Application" nu contează cum îl instanțiați. Întotdeauna folosesc CreateObject pentru a instanțializa referințele obiectului la bibliotecile externe, în acest fel pot trece între legarea timpurie și târzie și trebuie să trec doar o linie (nu două) - linia care
adăugat autor JimmyPena, sursa

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

0
adăugat
Însă articolul din Wikipedia despre legarea târzie ( en.wikipedia.org/wiki/Late_binding ) spune că "Legarea târzie este adesea confundată cu expedierea dinamică, dar există diferențe semnificative". Deci sunt aceleași sau nu? Dacă acestea sunt aceleași, atunci pagina wikipedia trebuie schimbată.
adăugat autor Alexander Bird, sursa
adăugat autor Baggers, sursa

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.

0
adăugat
"obiectul și funcția nu sunt legate până la timpul de execuție" Această afirmație pare să însemne că un obiect există înainte de timpul de execuție. Nu sunt obiecte care rulează pur și simplu entități de timp? Este clasa obiectului care există la momentul compilării. Acest lucru ar putea fi mai bine declarat ca "apelul pentru funcții și implementarea acestuia nu sunt legate până la timpul de execuție"
adăugat autor programmerravi, sursa
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.

0
adăugat

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.

0
adăugat