В чем разница между ранним и поздним связыванием?

в скомпилированных языках разница очевидна.

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

в первом примере, компилятор может делать всякие интересные вещи во время компиляции. Во-вторых, вы просто должны надеяться, что тот, кто использует этот метод, делает это ответственно. (Конечно, новые JVMs поддерживают Class<? extends Foo> klass структура, которая может значительно уменьшить этот риск.)

еще одно преимущество заключается в том, что IDEs может ссылаться на определение класса, так как оно объявлено прямо в метод. Вызов create_something (Foo) может быть очень далеко от определения метода, и если вы смотрите на определение метода, было бы неплохо увидеть реализацию.

основным преимуществом позднего связывания является то, что оно упрощает такие вещи, как инверсия контроля, а также некоторые другие виды использования полиморфизма и утиного типа (если ваш язык поддерживает такие вещи).

взято непосредственно из http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

существует два способа использования автоматизации (или Ole-автоматизации) для программно управлять другим приложением.

поздняя привязка использует CreateObject для создания и экземпляра объект приложения, которым вы можете управлять. Например, для создания новый экземпляр Excel с использованием поздней привязки:

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

С другой стороны, управление существующим экземпляром Excel (если Excel уже открыт) Вы бы использовали GetObject (независимо от того, вы используете раннюю или позднюю привязку):

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

чтобы использовать раннюю привязку, вам сначала нужно установить ссылку в проект для приложения, которым вы хотите управлять. В Редакторе VB любое приложение Office или в самом VB можно сделать, выбрав Инструменты + ссылки и выбор приложения, которое вы хотите от список (например, " Microsoft Excel 8.0 объектная библиотека.)"

создать новый экземпляр Excel с помощью раннего связывания:

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

В любом случае, кстати, вы можете сначала попробовать получить существующую экземпляр Excel, и если это возвращает ошибку, вы можете создать новый экземпляр в обработчике ошибок.

аналогичный, но более подробный ответ из книги Герберта Шильдта C++: -

раннее связывание относится к событиям, которые происходят во время компиляции. По сути, раннее связывание происходит, когда вся информация, необходимая для вызова функции, известна во время компиляции. (Иначе говоря, раннее связывание означает, что объект и вызов функции связаны во время компиляции.) Примеры ранней привязки включают обычные вызовы функций (включая стандартные библиотечные функции), перегруженные вызовы функций и перегруженные операторы. Главным преимуществом раннего связывания является эффективность. Поскольку вся информация, необходимая для вызова функции, определяется во время компиляции, эти типы вызовов функций очень быстры.

противоположностью ранней привязки является поздняя привязка. Позднее связывание означает для вызова функций, которые не разрешены до времени выполнения. Виртуальные функции используются для достижения поздней привязки. Как вы знаете, когда доступ осуществляется через базовый указатель или ссылку, фактически вызываемая виртуальная функция определяется тип объекта, на который указывает указатель. Поскольку в большинстве случаев это невозможно определить во время компиляции, объект и функция не связаны до времени выполнения. Основным преимуществом поздней привязки является гибкость. В отличие от раннее связывание, позднее связывание позволяет создавать программы, которые могут реагировать на события, происходящие во время выполнения программы, не создавая большое количество " кода непредвиденных обстоятельств."Имейте в виду, что, поскольку вызов функции не разрешен до времени выполнения, поздно привязка может привести к несколько более медленному времени выполнения. Однако сегодня быстрые компьютеры значительно сократили время выполнения, связанное с поздней привязкой.

в интерпретируемых языках, разница немного более тонким.

Руби:

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

потому что Ruby (как правило) не компилируется, нет компилятора, чтобы сделать отличный передний материал. Рост JRuby означает, что больше Ruby компилируется в эти дни, хотя, что делает его более похожим на Java, выше.

проблема с IDEs все еще стоит: платформа, такая как Eclipse, может искать определения классов, если вы жестко их кодируете, но не можете, если вы оставите их до абонент.

инверсия управления не очень популярна в Ruby, вероятно, из-за ее крайней гибкости во время выполнения, но Rails широко использует позднюю привязку, чтобы уменьшить количество конфигурации, необходимой для запуска вашего приложения.

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

это выводит

adult1
child1

в начале связывания компилятор будет иметь доступ ко всем методам у ребенка и подростка но в поздней привязке (во время выполнения) он будет проверять переопределенные методы во время выполнения.

следовательно, method1 (от дочерней -- ранней привязки) будет переопределен method1 от взрослого во время выполнения(поздняя привязка) Тогда он будет реализовывать method1 от ребенка, так как нет method1 в method1 в подростке.

Примечание. что если у ребенка не было method1, то код в основном не будет компилироваться.

полиморфизм времени компиляции также называется перегрузкой или ранней привязкой или статической привязкой, когда у нас есть одно и то же имя метода с различным поведением. При реализации нескольких прототипов одного и того же метода и в нем происходит разное поведение. Ранняя привязка относится к первой компиляции программы . Но в конце привязки объект runtime происходит в программе. Также называется динамическим связыванием или переопределением или полиморфизмом времени выполнения.