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


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


75
2017-08-14 02:24


Ursprung


Antworten:


Die kurze Antwort lautet, dass die frühe (oder statische) Bindung auf die Kompilierzeitbindung und die späte (oder dynamische) Bindung auf die Laufzeitbindung verweist (z. B. bei der Verwendung von Reflektion).


53
2017-08-14 02:16



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 Dinge erledigen. In der zweiten muss man nur hoffen, dass derjenige, der die Methode nutzt, dies verantwortungsvoll tut. (Natürlich, neuere JVMs unterstützen die Class<? extends Foo> klass Struktur, die dieses Risiko stark reduzieren kann.)

Ein weiterer Vorteil ist, dass IDEs auf die Klassendefinition verweisen können, da sie direkt in der Methode deklariert ist. Der Aufruf von create_something (Foo) könnte sein sehr weit entfernt von der Methodendefinition, und wenn Sie sich die Methodendefinition anschauen, könnte es schön sein, die Implementierung zu sehen.

Der große Vorteil der späten Bindung ist, dass sie Dinge wie Inversion-of-Control einfacher macht, sowie bestimmte andere Anwendungen von Polymorphismus und Duck-Typing (wenn Ihre Sprache solche Dinge unterstützt).


15
2017-08-14 02:16



Direkt genommen von http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Es gibt zwei Möglichkeiten, die Automatisierung (oder OLE-Automatisierung) zu verwenden   Programmgesteuert eine andere Anwendung steuern.

Late Binding verwendet CreateObject zum Erstellen und Instanz von   Anwendungsobjekt, das Sie dann steuern können. Zum Beispiel, um zu erstellen   eine neue Instanz von Excel, die die späte Bindung verwendet:

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

Auf der anderen Seite, um eine vorhandene Instanz von Excel (wenn   Excel ist bereits geöffnet) Sie würden GetObject verwenden (egal ob   Sie verwenden frühe oder späte Bindung):

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

Um die frühzeitige Bindung zu verwenden, müssen Sie zuerst eine Referenz in Ihrem erstellen   projizieren Sie auf die Anwendung, die Sie bearbeiten möchten. Im VB Editor von   In einer Office-Anwendung oder in VB selbst wählen Sie dies aus   Werkzeuge + Referenzen und wählen Sie die gewünschte Anwendung aus dem   Liste (z. B. "Microsoft Excel 8.0-Objektbibliothek").

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

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

In jedem Fall können Sie zunächst versuchen, ein existierendes zu erhalten   Instanz von Excel, und wenn das einen Fehler zurückgibt, können Sie ein neues erstellen   Instanz in Ihrem Fehlerhandler.


6
2017-08-14 02:21



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

Frühe Bindung bezieht sich auf Ereignisse, die bei der Kompilierung auftreten. Im Wesentlichen tritt eine frühe Bindung auf, wenn alle Informationen, die zum Aufrufen einer Funktion benötigt werden, zum Zeitpunkt der Kompilierung bekannt sind. (Mit anderen Worten, frühe Bindung bedeutet, dass ein Objekt und ein Funktionsaufruf während der Kompilierung gebunden werden.) Beispiele für frühe Bindung sind normale Funktionsaufrufe (einschließlich Standardbibliotheksfunktionen), überlastete Funktionsaufrufe und überlastete Operatoren. Der Hauptvorteil der frühen Bindung ist die Effizienz. Da alle zum Aufrufen einer Funktion erforderlichen Informationen zum Zeitpunkt der Kompilierung ermittelt werden, sind diese Arten von Funktionsaufrufen sehr schnell.

Das Gegenteil der frühen Bindung ist die späte Bindung. Late Binding bezieht sich auf um Aufrufe auszuführen, 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 Kompilierzeit festgestellt werden kann, sind 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 ermöglicht die späte Bindung die Erstellung von Programmen, die auf Ereignisse reagieren können, die während der Ausführung des Programms auftreten, ohne dass ein große Menge an "Kontingenz-Code". 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 haben schnelle Computer jedoch die Ausführungszeiten im Zusammenhang mit der späten Bindung erheblich reduziert.


4



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 wird, gibt es keinen Compiler, um die raffinierten Up-Front-Sachen zu machen. Das Wachstum von JRuby bedeutet, dass heutzutage mehr Ruby kompiliert wird, wodurch es mehr wie Java wirkt.

Das Problem mit IDEs steht immer noch: 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 wegen seiner extremen Laufzeitflexibilität, aber Rails nutzt die späte Bindung sehr, um die Konfigurationsmenge zu reduzieren, die für die Anwendung benötigt wird.


3



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 Jugendlichem Bei der späten Bindung (zur Laufzeit) wird jedoch nach Methoden gesucht, die außer Kraft gesetzt werden zur Laufzeit.

Daher wird method1 (von Kind - frühe Bindung) durch die Methode1 von adult zur Laufzeit überschrieben (späte Bindung). Dann wird es method1 von Kind implementieren, da es in Methode1 in Teenager keine method1 gibt.

Beachten Sie, dass, wenn Kind keine Methode1 hat, der Code im Hauptprogramm nicht kompiliert wird.


0



Der Kompilierzeit-Polymorphismus wird auch als Überladen oder frühe Bindung oder statische Bindung bezeichnet, wenn wir denselben Methodennamen mit unterschiedlichen Verhaltensweisen haben. Durch die Implementierung der multiplen Prototyp der gleichen Methode und unterschiedliche Verhalten tritt in ihm auf. Frühe Bindung bezieht sich auf die erste Kompilierung des Programms. Aber in der späten Bindung Objekt ist Laufzeit im Programm auftritt. Wird auch als Dynamic Binding oder Overriding oder Runtime Polymorphism bezeichnet.


0