早期绑定和后期绑定有什么区别？

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

题

早期绑定和后期绑定有什么区别？

有帮助吗？

解决方案

简而言之，早期（或静态）绑定是指编译时绑定，后期（或动态）绑定是指运行时绑定（例如，当您使用反射时）。

其他提示

在编译语言中，差异是明显的。

爪哇：

//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自动化）来编程控制另一个应用程序的方法。

后期绑定使用CreateObject来创建应用程序对象的创建和实例，然后您可以控制。例如，使用较晚绑定创建一个新的Excel实例：

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

另一方面，要操纵Excel的现有实例（如果已经打开），则将使用GetObject（无论您是使用早期还是晚期绑定）：

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

要使用早期绑定，您首先需要将项目中的参考设置为要操纵的应用程序。在任何Office应用程序的VB编辑器或VB本身中，您可以通过选择工具 +参考并从列表中选择所需的应用程序来执行此操作（例如“Microsoft Excel 8.0 对象库”）。

要使用早期绑定创建新的 Excel 实例：

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

顺便说一句，您可以首先尝试获得Excel的现有实例，如果返回错误，则可以在错误处理程序中创建一个新实例。

Herbert Schildt 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

在早期绑定中，编译器将可以访问儿童和青少年中的所有方法，但在较晚的绑定（在运行时）中，它将检查在运行时覆盖的方法。

因此，方法1（来自儿童 - 早期结合）将被成人在运行时的方法1覆盖（较晚绑定），然后它将从儿童中实现Method1，因为Teenager中的Method1中没有Method1。

请注意，如果 child 没有 method1，则 main 中的代码将无法编译。

当我们具有相同的方法名称但具有不同的行为时，编译时多态性也称为重载或早期绑定或静态绑定。通过实现同一方法的多个原型，其中会出现不同的行为。早期绑定是指程序的第一次编译。但后期绑定对象是在程序运行时发生的。也称为动态绑定或重写或运行时多态性。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top