В чем разница между Ранним и Поздним Связыванием?

StackOverflow https://stackoverflow.com/questions/10580

Вопрос

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

Это было полезно?

Решение

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

Другие советы

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

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

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

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

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

Аналогичный, но более подробный ответ из книги Герберта Шилдта по 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, описанную выше.

Проблема с 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(от child - раннее связывание) будет переопределен method1 от adult во время выполнения (позднее связывание) Затем он будет реализовывать method1 от child, поскольку в method1 у teenager нет method1 в method1.

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

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

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top