Qual é a diferença entre vinculação antecipada e tardia?

Question

Qual é a diferença entre vinculação antecipada e tardia?

Answer 1

A resposta curta é que a ligação inicial (ou estática) refere-se à ligação em tempo de compilação e a ligação tardia (ou dinâmica) refere-se à ligação em tempo de execução (por exemplo, quando você usa reflexão).

Answer 2

Em linguagens compiladas, a diferença é gritante.

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

No primeiro exemplo, o compilador pode fazer todo tipo de coisas interessantes em tempo de compilação.No segundo, basta torcer para que quem utiliza o método o faça com responsabilidade.(Claro, JVMs mais recentes suportam o Class<? extends Foo> klass estrutura, o que pode reduzir bastante esse risco.)

Outro benefício é que os IDEs podem vincular-se à definição da classe, já que ela é declarada ali mesmo no método.A chamada para create_something(Foo) pode ser muito longe da definição do método, e se você estiver olhando a definição do método, pode ser bom ver a implementação.

A principal vantagem da vinculação tardia é que ela facilita coisas como inversão de controle, bem como alguns outros usos de polimorfismo e digitação de pato (se sua linguagem suportar tais coisas).

Answer 3

Extraído diretamente de http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Existem duas maneiras de usar a automação (ou automação OLE) para controlar programaticamente outro aplicativo.

A ligação tardia usa o CreateObject para criar e a instância do objeto de aplicativo, que você pode controlar.Por exemplo, para criar uma nova instância do Excel usando a ligação tardia:

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

Por outro lado, para manipular uma instância existente do Excel (se o Excel já estiver aberto), você usaria o GetObject (independentemente de estar usando a ligação antecipada ou tardia):

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

Para usar a ligação precoce, você primeiro precisa definir uma referência em seu projeto para o aplicativo que deseja manipular.No editor VB de qualquer aplicativo do Office, ou no próprio VB, você faz isso selecionando ferramentas + referências e selecionando o aplicativo desejado da lista (por exemplo,“Biblioteca de Objetos do Microsoft Excel 8.0”).

Para criar uma nova instância do Excel usando ligação antecipada:

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

Em ambos os casos, aliás, você pode primeiro tentar obter uma instância existente do Excel e, se isso retornar um erro, poderá criar uma nova instância no seu manipulador de erros.

Answer 4

Resposta semelhante, mas mais detalhada, do livro Herbert Schildt C++: -

A ligação antecipada refere-se a eventos que ocorrem em tempo de compilação.Em essência, a ligação antecipada ocorre quando todas as informações necessárias para chamar uma função são conhecidas em tempo de compilação.(Dito de outra forma, ligação antecipada significa que um objeto e uma chamada de função são vinculados durante a compilação.) Exemplos de ligação antecipada incluem chamadas de função normais (incluindo funções de biblioteca padrão), chamadas de função sobrecarregadas e operadores sobrecarregados.A principal vantagem da vinculação antecipada é a eficiência.Como todas as informações necessárias para chamar uma função são determinadas em tempo de compilação, esses tipos de chamadas de função são muito rápidos.

O oposto da vinculação antecipada é a vinculação tardia.A ligação tardia refere -se a chamadas de função que não são resolvidas até o tempo de execução.Funções virtuais são usadas para obter ligação tardia.Como você sabe, quando o acesso é feito através de um ponteiro base ou referência, a função virtual realmente chamada é determinada pelo tipo de objeto apontado pelo ponteiro.Como na maioria dos casos isso não pode ser determinado em tempo de compilação, o objeto e a função não são vinculados até o tempo de execução.A principal vantagem da vinculação tardia é a flexibilidade.Ao contrário da ligação precoce, a ligação tardia permite criar programas que possam responder a eventos que ocorrem enquanto o programa é executado sem precisar criar uma grande quantidade de "código de contingência". Lembre -se de que, como uma chamada de função não é resolvida até o tempo de execução, a ligação tardia pode proporcionar tempos de execução um pouco mais lentos.No entanto, hoje, os computadores rápidos reduziram significativamente os tempos de execução relacionados à vinculação tardia.

Answer 5

Nas linguagens interpretadas, a diferença é um pouco mais sutil.

Rubi:

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

Como Ruby (geralmente) não é compilado, não há um compilador para fazer o trabalho inicial bacana.O crescimento do JRuby significa que mais Ruby é compilado atualmente, fazendo com que ele atue mais como o Java, acima.

O problema com IDEs ainda permanece:uma plataforma como o Eclipse pode procurar definições de classe se você codificá-las, mas não pode se você deixá-las para o chamador.

A inversão de controle não é muito popular em Ruby, provavelmente por causa de sua extrema flexibilidade de tempo de execução, mas o Rails faz grande uso de ligação tardia para reduzir a quantidade de configuração necessária para colocar sua aplicação em funcionamento.

Answer 6

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

Isto irá imprimir

adult1
child1

Na ligação antecipada, o compilador terá acesso a todos os métodos em crianças e adolescentes, mas na ligação tardia (em tempo de execução), ele verificará os métodos que serão substituídos no tempo de execução.

Portanto, o método1 (da criança - a ligação antecipada) será substituído pelo método1 do adulto em tempo de execução (ligação tardia), então ele implementará o método1 da criança, pois não há método1 no método1 no adolescente.

Observe que se o filho não tivesse um método1, o código principal não seria compilado.

Answer 7

O polimorfismo em tempo de compilação também é chamado de sobrecarga ou ligação inicial ou ligação estática quando temos o mesmo nome de método com comportamentos diferentes.Ao implementar o protótipo múltiplo do mesmo método, ocorre um comportamento diferente nele.A vinculação antecipada refere-se à primeira compilação do programa.Mas na ligação tardia, o objeto é o tempo de execução que ocorre no programa.Também chamado de ligação ou substituição dinâmica ou polimorfismo de tempo de execução.