¿Cuál es la diferencia entre la vinculación temprana y tardía?

¿Cuál es la diferencia entre encuadernación anticipada y tardía?

La respuesta corta es que el enlace temprano (o estático) se refiere al enlace en tiempo de compilación y el enlace tardío (o dinámico) se refiere al enlace en tiempo de ejecución (por ejemplo, cuando usa la reflexión).

En los lenguajes compilados, la diferencia es marcada.

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

En el primer ejemplo, el compilador puede hacer todo tipo de cosas interesantes en tiempo de compilación. En el segundo, solo hay que esperar que quien use el método lo haga de manera responsable. (Por supuesto, las JVM más nuevas admiten la Class<? extends Foo> klassestructura, lo que puede reducir en gran medida este riesgo).

Otro beneficio es que los IDE pueden acceder a la definición de la clase, ya que se declara allí mismo en el método. La llamada a create_something (Foo) puede estar muy lejos de la definición del método, y si está mirando la definición del método, sería bueno ver la implementación.

La principal ventaja de la vinculación tardía es que facilita cosas como la inversión de control, así como otros usos del polimorfismo y la tipificación de pato (si su lenguaje admite tales cosas).

Tomado directamente de http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Hay dos formas de utilizar Automatización (o Automatización OLE) para controlar mediante programación otra aplicación.

El enlace tardío usa CreateObject para crear una instancia del objeto de la aplicación, que luego puede controlar. Por ejemplo, para crear una nueva instancia de Excel usando enlace tardío:

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

Por otro lado, para manipular una instancia existente de Excel (si Excel ya está abierto), usaría GetObject (independientemente de si está usando enlace temprano o tardío):

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

Para utilizar el enlace anticipado, primero debe establecer una referencia en su proyecto a la aplicación que desea manipular. En el VB Editor de cualquier aplicación de Office, o en el propio VB, puede hacer esto seleccionando Herramientas + Referencias y seleccionando la aplicación que desea de la lista (por ejemplo, “Biblioteca de objetos de Microsoft Excel 8.0”).

Para crear una nueva instancia de Excel usando el enlace anticipado:

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

En cualquier caso, por cierto, primero puede intentar obtener una instancia existente de Excel, y si eso devuelve un error, puede crear una nueva instancia en su controlador de errores.

Respuesta similar pero más detallada del libro C ++ de Herbert Schildt: -

El enlace temprano se refiere a eventos que ocurren en el momento de la compilación. En esencia, la vinculación temprana ocurre cuando toda la información necesaria para llamar a una función se conoce en tiempo de compilación. (Dicho de otra manera, la vinculación temprana significa que un objeto y una llamada a función están vinculadas durante la compilación). Ejemplos de vinculación temprana incluyen llamadas a funciones normales (incluidas funciones de biblioteca estándar), llamadas a funciones sobrecargadas y operadores sobrecargados. La principal ventaja del enlace anticipado es la eficiencia. Debido a que toda la información necesaria para llamar a una función se determina en tiempo de compilación, estos tipos de llamadas a funciones son muy rápidos.

Lo opuesto al enlace temprano es el enlace tardío. El enlace tardío se refiere a las llamadas a funciones que no se resuelven hasta el momento de la ejecución. Las funciones virtuales se utilizan para lograr un enlace tardío. Como sabe, cuando el acceso es a través de un puntero base o una referencia, la función virtual realmente llamada está determinada por el tipo de objeto al que apunta el puntero. Dado que en la mayoría de los casos esto no se puede determinar en tiempo de compilación, el objeto y la función no se vinculan hasta el tiempo de ejecución. La principal ventaja de la encuadernación tardía es la flexibilidad. A diferencia del enlace temprano, el enlace tardío le permite crear programas que pueden responder a eventos que ocurren mientras el programa se ejecuta sin tener que crear una gran cantidad de "código de contingencia". Tenga en cuenta que debido a que una llamada a una función no se resuelve hasta el tiempo de ejecución, el enlace tardío puede hacer que los tiempos de ejecución sean algo más lentos. Sin embargo hoy,

En los lenguajes interpretados, la diferencia es un poco más sutil.

Rubí:

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

Debido a que Ruby (generalmente) no está compilado, no hay un compilador para hacer las cosas ingeniosas desde el principio. Sin embargo, el crecimiento de JRuby significa que se compila más Ruby en estos días, lo que lo hace actuar más como Java, arriba.

El problema con los IDE sigue en pie: una plataforma como Eclipse puede buscar definiciones de clases si las codifica, pero no puede hacerlo si las deja en manos de la persona que llama.

La inversión de control no es muy popular en Ruby, probablemente debido a su extrema flexibilidad en tiempo de ejecución, pero Rails hace un gran uso del enlace tardío para reducir la cantidad de configuración necesaria para que su aplicación funcione.

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

Esto se imprimirá

adult1
child1

En el enlace temprano, el compilador tendrá acceso a todos los métodos en niños y adolescentes, pero en el enlace tardío (en tiempo de ejecución), buscará métodos que se anulen en tiempo de ejecución.

Por lo tanto, el método1 (de niño - enlace temprano) será anulado por el método1 de adulto en tiempo de ejecución (enlace tardío) Luego implementará el método1 del niño ya que no hay método1 en el método1 en el adolescente.

Tenga en cuenta que si el niño no tuviera un método1, el código principal no se compilaría.

El polimorfismo en tiempo de compilación también se llama sobrecarga o enlace temprano o enlace estático cuando tenemos el mismo nombre de método con diferentes comportamientos. Al implementar el prototipo múltiple de un mismo método se produce en él un comportamiento diferente. La vinculación anticipada se refiere a la primera compilación del programa. Pero en el último objeto de enlace se produce el tiempo de ejecución en el programa. También se denomina enlace dinámico o anulación o polimorfismo en tiempo de ejecución.