7 ответов

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

    Рубин:

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

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

  2. 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 (from child — early binding) будет переопределен method1 from adult во время выполнения (late binding)
    Тогда он будет реализовывать method1 от ребенка, так как нет method1 в method1 в подростке.

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

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

  4. Взято непосредственно из 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 Object Library»).

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

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

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

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

    Ява:

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

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

  6. Похожий, но более подробный ответ из Herbert Schildt c++ book:-

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

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

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