Was ist der Unterschied zwischen früher und später Bindung?

Was ist der Unterschied zwischen früher und später Bindung?

Die kurze Antwort lautet, dass sich die frühe (oder statische) Bindung auf die Bindung zur Kompilierungszeit und die späte (oder dynamische) Bindung auf die Laufzeitbindung bezieht (z. B. wenn Sie Reflection verwenden).

In kompilierten Sprachen ist der Unterschied stark.

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

Im ersten Beispiel kann der Compiler zur Kompilierungszeit alle möglichen netten Dinge erledigen. Im zweiten Fall muss man nur hoffen, dass jeder, der die Methode verwendet, dies verantwortungsbewusst tut. (Natürlich unterstützen neuere JVMs die Class<? extends Foo> klassStruktur, wodurch dieses Risiko erheblich reduziert werden kann.)

Ein weiterer Vorteil ist, dass IDEs einen Hotlink zur Klassendefinition erstellen können, da diese direkt in der Methode deklariert ist. Der Aufruf von create_something (Foo) ist möglicherweise sehr weit von der Methodendefinition entfernt. Wenn Sie sich die Methodendefinition ansehen, ist es möglicherweise hilfreich, die Implementierung zu sehen.

Der Hauptvorteil der späten Bindung besteht darin, dass sie Dinge wie die Inversion der Kontrolle sowie bestimmte andere Verwendungen von Polymorphismus und Ententypisierung erleichtert (wenn Ihre Sprache solche Dinge unterstützt).

Entnommen direkt von http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Es gibt zwei Möglichkeiten, mithilfe der Automatisierung (oder OLE-Automatisierung) eine andere Anwendung programmgesteuert zu steuern.

Bei der späten Bindung wird CreateObject verwendet, um eine Instanz des Anwendungsobjekts zu erstellen, die Sie dann steuern können. So erstellen Sie beispielsweise eine neue Instanz von Excel mithilfe der späten Bindung:

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

Um eine vorhandene Instanz von Excel zu bearbeiten (wenn Excel bereits geöffnet ist), verwenden Sie GetObject (unabhängig davon, ob Sie eine frühe oder eine späte Bindung verwenden):

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

Um die frühzeitige Bindung zu verwenden, müssen Sie in Ihrem Projekt zunächst einen Verweis auf die Anwendung festlegen, die Sie bearbeiten möchten. Im VB-Editor einer Office-Anwendung oder in VB selbst wählen Sie dazu Extras + Referenzen und die gewünschte Anwendung aus der Liste aus (z. B. „Microsoft Excel 8.0-Objektbibliothek“).

So erstellen Sie eine neue Excel-Instanz mithilfe der frühen Bindung:

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

In beiden Fällen können Sie übrigens zuerst versuchen, eine vorhandene Excel-Instanz abzurufen. Wenn dies einen Fehler zurückgibt, können Sie eine neue Instanz in Ihrem Fehlerhandler erstellen.

Ähnliche, aber detailliertere Antwort aus dem Herbert Schildt C ++ Buch: -

Frühe Bindung bezieht sich auf Ereignisse, die zur Kompilierungszeit auftreten. Im Wesentlichen tritt eine frühe Bindung auf, wenn alle zum Aufrufen einer Funktion erforderlichen Informationen zur Kompilierungszeit bekannt sind. (Anders ausgedrückt bedeutet frühes Binden, dass ein Objekt und ein Funktionsaufruf während der Kompilierung gebunden werden.) Beispiele für frühes Binden sind normale Funktionsaufrufe (einschließlich Standardbibliotheksfunktionen), überladene Funktionsaufrufe und überladene Operatoren. Der Hauptvorteil einer frühen Bindung ist die Effizienz. Da alle zum Aufrufen einer Funktion erforderlichen Informationen zur Kompilierungszeit ermittelt werden, sind diese Arten von Funktionsaufrufen sehr schnell.

Das Gegenteil von früher Bindung ist späte Bindung. Späte Bindung bezieht sich auf Funktionsaufrufe, die erst zur Laufzeit aufgelöst werden. Virtuelle Funktionen werden verwendet, um eine späte Bindung zu erreichen. Wie Sie wissen, wird beim Zugriff über einen Basiszeiger oder eine Referenz die tatsächlich aufgerufene virtuelle Funktion durch den Objekttyp bestimmt, auf den der Zeiger zeigt. Da dies in den meisten Fällen nicht zur Kompilierungszeit ermittelt werden kann, werden das Objekt und die Funktion erst zur Laufzeit verknüpft. Der Hauptvorteil der späten Bindung ist die Flexibilität. Im Gegensatz zur frühen Bindung können Sie mit der späten Bindung Programme erstellen, die auf Ereignisse reagieren können, die während der Ausführung des Programms auftreten, ohne dass eine große Menge an "Notfallcode" erstellt werden muss. Beachten Sie, dass eine späte Bindung zu etwas langsameren Ausführungszeiten führen kann, da ein Funktionsaufruf erst zur Laufzeit aufgelöst wird. Heute jedoch

In interpretierten Sprachen ist der Unterschied etwas subtiler.

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)

Da Ruby (im Allgemeinen) nicht kompiliert ist, gibt es keinen Compiler, der die raffinierten Vorarbeiten erledigt. Das Wachstum von JRuby bedeutet jedoch, dass heutzutage mehr Ruby kompiliert wird, sodass es sich eher wie Java oben verhält.

Das Problem mit IDEs besteht weiterhin: Eine Plattform wie Eclipse kann Klassendefinitionen nachschlagen, wenn Sie sie fest codieren, aber nicht, wenn Sie sie dem Aufrufer überlassen.

Inversion-of-Control ist in Ruby nicht besonders beliebt, wahrscheinlich aufgrund seiner extremen Laufzeitflexibilität. Rails nutzt jedoch die späte Bindung, um den Konfigurationsaufwand für den Start Ihrer Anwendung zu verringern.

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

Dies wird ausgedruckt

adult1
child1

Bei der frühen Bindung hat der Compiler Zugriff auf alle Methoden in Kind und Teenager, bei der späten Bindung (zur Laufzeit) wird jedoch nach Methoden gesucht, die zur Laufzeit überschrieben werden.

Daher wird Methode1 (vom Kind - frühe Bindung) zur Laufzeit von der Methode1 vom Erwachsenen überschrieben (späte Bindung). Dann wird Methode1 vom Kind implementiert, da es im Teenager keine Methode1 in Methode1 gibt.

Beachten Sie, dass der Code im Main nicht kompiliert werden würde, wenn das Kind keine Methode1 hätte.

Der Polymorphismus zur Kompilierungszeit wird auch als Überladung oder frühe Bindung oder statische Bindung bezeichnet, wenn wir denselben Methodennamen mit unterschiedlichen Verhaltensweisen haben. Durch die Implementierung des Mehrfachprototyps derselben Methode tritt darin ein unterschiedliches Verhalten auf. Frühe Bindung bezieht sich auf die erste Zusammenstellung des Programms. Aber im späten Bindungsobjekt tritt die Laufzeit im Programm auf. Wird auch als dynamische Bindung oder Überschreiben oder Laufzeitpolymorphismus bezeichnet.