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

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

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

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

еще одно преимущество заключается в том, что IDE могут ссылаться на определение класса, поскольку оно объявлено прямо там метод. Вызов 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++: -

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

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

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

Ruby:

# 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, выше.

проблема с IDE все еще стоит: платформа, подобная 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, то код в основном не компилировался бы.

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