В чем разница между ранним и поздним переплетением?

Ответ 1

Короткий ответ заключается в том, что ранняя (или статическая) привязка относится к привязке времени компиляции и позднему (или динамическому) привязке относится к привязке времени выполнения (например, когда вы используете отражение).

Ответ 2

В скомпилированных языках разница является абсолютной.

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

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

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

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

Ответ 3

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

Существует два способа использования Automation (или OLE Automation) для программным способом управлять другим приложением.

Позднее связывание использует 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, и если это возвращает ошибку, вы можете создать новую экземпляр в обработчике ошибок.

Ответ 4

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

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

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

Ответ 5

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

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 отлично использует позднюю привязку, чтобы уменьшить объем конфигурации, необходимый для запуска вашего приложения.

Ответ 6

Позднее связывание или динамическое связывание - это механизм компьютерного программирования, в котором метод, вызываемый объектом, просматривается по имени во время выполнения.

С ранним связыванием или статическим связыванием фаза компиляции фиксирует все типы переменных и выражений. Обычно это сохраняется в скомпилированной программе как смещение в таблице виртуальных методов ( "v-table" ) и очень эффективно. При позднем связывании компилятор не располагает достаточной информацией, чтобы проверить, что метод существует, не говоря уже о привязке к его конкретному слоту на v-таблице. Вместо этого метод проверяется по имени во время выполнения.

Ответ 7

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

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

Следовательно, метод1 (от child-early binding) будет переопределен методом 1 от взрослого во время выполнения (поздняя привязка) Затем он будет реализовывать метод1 из дочернего элемента, поскольку в подростке нет метода1 в методе 1.

Обратите внимание, что если у ребенка не было метода1, тогда код в основном не компилировался.

Ответ 8

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