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

75

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

Возможный дубликатEarly and late binding berkay
Late and early binding jfs
Могу ли я сказать, что рано = прямой вызов функции, а поздно = вызов функции через указатель функции? Меня не перестает удивлять то, как программисты имеют способ воспринимать простые концепции и заставлять их казаться намного сложнее, чем они есть (как демонстрация интеллекта?). Программирование по своей природе является очень легкой областью изучения, пока вы не приступите к таким вещам, как создание типа с плавающей запятой или разработка компиляторов. Bob Blogge

Ваш Ответ

7   ответов
0
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 от child, поскольку в method1 у подростка нет method1.

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

4

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

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

"объект и функция не связаны до времени выполнения" Это утверждение, кажется, подразумевает, что объект существует до времени выполнения. Разве объекты не являются объектами времени исполнения? Это класс объекта, который существует во время компиляции. Это может быть лучше сформулировано как «функция по вызову и ее реализация не связаны до времени выполнения».
6

http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

There are two ways to use Automation (or OLE Automation) to programmatically control another application.

Late binding uses CreateObject to create and instance of the application object, which you can then control. For example, to create a new instance of Excel using late binding:

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

On the other hand, to manipulate an existing instance of Excel (if Excel is already open) you would use GetObject (regardless whether you're using early or late binding):

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

To use early binding, you first need to set a reference in your project to the application you want to manipulate. In the VB Editor of any Office application, or in VB itself, you do this by selecting Tools + References, and selecting the application you want from the list (e.g. “Microsoft Excel 8.0 Object Library”).

To create a new instance of Excel using early binding:

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

In either case, incidentally, you can first try to get an existing instance of Excel, and if that returns an error, you can create a new instance in your error handler.

Я знаю, что этот ответ старый и получен откуда-то еще, но он не точный. Позднее связывание подразумевает использование CreateObject, но CreateObject не обязательно подразумевает позднее связывание. Привязка не применяется к методу создания объекта, а только к тому, как он объявлен. Если вы объявите свой объект как Excel.Application & quot; не имеет значения, как вы его создаете. Я всегда использую CreateObject для создания экземпляров ссылок на объекты во внешних библиотеках, таким образом я могу переключаться между ранним и поздним связыванием и должен переключать только одну строку (не две) - строку, которая объявляет объект.
3

Рубин:

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

Этот пункт применим также к скомпилированным языкам, которые могут включать компоненты, скомпилированные JIT и включенные во время выполнения для реализации плагинов или динамических платформ. Некоторые канонические примеры этого существуют в Java, и, конечно, в Ruby и Python. Экстремальным примером является Erlang, где среда выполнения может загружать две версии любого модуля одновременно для текущих обновлений / понижений. Таким образом, хотя большая часть кода Erlang (большая часть?) Написана в виде статически типизированных чистых функций, требования времени выполнения требуют позднего связывания и динамических типов под капотом.
15

Джава:

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

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

0

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

57

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

Лучше ответ здесь stackoverflowstackoverflow.com/questions/484214/early-and-late-binding
Но статья в википедии о позднем связывании (en.wikipedia.org/wiki/Late_binding) говорит, что «позднее связывание часто путают с динамической диспетчеризацией, но есть существенные различия». Так они одинаковые или нет? Если они одинаковые, то эту страницу википедии нужно изменить.

Похожие вопросы