Question

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

Answer 1

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

Answer 2

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

爪哇：

//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）的调用可能非常远离方法定义，如果您正在查看方法定义，那么查看实现可能会很好。

后期绑定的主要优点是它使控件反转更容易，以及多态和鸭子类型的某些其他用法（如果您的语言支持此类事情）。

Answer 3

直接来自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对象库”）。

使用早期绑定创建Excel的新实例：
 Dim oXL As Excel.Application
 Set oXL = New Excel.Application
在任何一种情况下，顺便说一下，你可以先尝试获得一个现有的 Excel的实例，如果返回错误，则可以创建新的错误处理程序中的实例。

Answer 4

Herbert Schildt C ++书中类似但更详细的答案： -

早期绑定是指在编译时发生的事件。本质上，早期绑定发生在编译时需要调用函数所需的所有信息时。（换句话说，早期绑定意味着在编译期间绑定对象和函数调用。）早期绑定的示例包括正常函数调用（包括标准库函数），重载函数调用和重载运算符。早期绑定的主要优点是效率。因为调用函数所需的所有信息都是在编译时确定的，所以这些类型的函数调用非常快。

早期结合的反义词是晚期结合。后期绑定是指处理在运行时才解决的调用。虚函数用于实现后期绑定。如您所知，当通过基指针或引用进行访问时，实际调用的虚函数由指针指向的对象类型决定。因为在大多数情况下无法在编译时确定，所以在运行时之前不会链接对象和函数。后期绑定的主要优点是灵活性。与早期绑定不同，后期绑定允许您创建程序，这些程序可以响应程序执行时发生的事件而无需创建大量的“应急代码”。请记住，因为函数调用直到运行时才解决，所以后期绑定可能会导致执行时间稍慢。然而，今天，快速计算机显着缩短了与后期绑定相关的执行时间。

Answer 5

在解释型语言中，差异更为微妙。

红宝石：

# 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很好地利用了后期绑定来减少使应用程序运行所需的配置量。

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

这将打印出来

adult1
child1

在早期绑定中，编译器可以访问所有方法在孩子和少年但是在后期绑定（在运行时），它将检查被覆盖的方法在运行时。

因此，在运行时，来自成人的method1将覆盖method1（来自子进程 - 早期绑定）（后期绑定）然后它将从子实现method1，因为在少年的method1中没有method1。

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

Answer 7

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

Answer 8

Java 中最简单的例子：

早期（静态或重载）绑定：

public class Duck {
    public static void quack(){
        System.out.println("Quack");
    }
}

public class RubberDuck extends Duck {
    public static void quack(){
        System.out.println("Piiiiiiiiii");
    }
}

public class EarlyTest {
    public static void main(String[] args) {
        Duck duck = new Duck();
        Duck rubberduck = new RubberDuck();

        duck.quack();
        rubberduck.quack(); //early binding - compile time
    }
}

结果是：

Quack
Quack

while 用于后期（动态或覆盖）绑定：

public class Duck {
    public void quack(){
        System.out.println("Quack");
    }
}

public class RubberDuck extends Duck {
    public void quack(){
        System.out.println("Piiiiiiiiii");
    }
}

public class LateTest {
    public static void main(String[] args){
        Duck duck = new Duck();
        Duck rubberduck = new RubberDuck();

        duck.quack();
        rubberduck.quack(); //late binding - runtime
    }
}

结果是：

Quack
Piiiiiiiiii

早期绑定发生在编译时，而后期绑定发生在运行时。

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

8 个答案: