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

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

直接从

有两种方法可以使用自动化（或OLE自动化）来 以编程方式控制另一个应用程序

后期绑定使用CreateObject来创建 应用程序对象，然后可以对其进行控制。例如，创建 使用后期绑定的Excel新实例：

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

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

另一方面，操作Excel的现有实例（如果 Excel已打开）您将使用GetObject（无论 您正在使用早绑定或晚绑定）：

要使用早期绑定，首先需要在 项目到要操作的应用程序。在的VB编辑器中 任何Office应用程序，或在VB中，都可以通过选择 工具+引用，并从 列表（例如“Microsoft Excel 8.0对象库”）

要使用早期绑定创建新的Excel实例，请执行以下操作：

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

顺便说一句，在这两种情况下，您都可以先尝试获取现有的 实例，如果返回错误，则可以创建新的 错误处理程序中的实例

---

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

爪哇：

//早期绑定：
公共创建_a_foo（*args）{
返回新的Foo（args）
}
my_foo=创建_a_foo（）；
//后期绑定：
公共创建（类klass，*args）{
klass.new_实例（args）
}
my_foo=创建某物（foo）；

---

在第一个示例中，编译器可以在编译时完成各种整洁的工作。在第二种情况下，你只需要希望无论谁使用这种方法都是负责任的。（当然，较新的JVM支持解释语言中的

类，区别稍微微妙一些

红宝石：

因为Ruby（通常）没有被编译，所以没有一个编译器来做这些漂亮的前期工作。然而，JRuby的发展意味着现在有更多的Ruby被编译，这使得它更像Java，如上所述

IDE的问题仍然存在：像Eclipse这样的平台可以在硬编码的情况下查找类定义，但如果将它们留给调用方，则无法查找

控制反转在Ruby中并不流行，可能是因为它在运行时具有极大的灵活性，但是Rails充分利用了后期绑定来减少应用程序运行所需的配置量。
简单的回答是早期（或静态）绑定指代编译时绑定和后期（或动态）绑定绑定指的是运行时绑定（例如，当你使用反射）时，
 < P> > Herbert Schildt C++书中类似但更详细的答案：-< /P>
早期绑定是指在编译时发生的事件。本质上，早期绑定发生在编译时调用函数所需的所有信息都已知的情况下。（换句话说，早期绑定意味着在编译期间绑定对象和函数调用。）早期绑定的示例包括正常函数调用（包括标准库函数）、重载函数调用和重载运算符。早期绑定的主要优点是效率。因为调用函数所需的所有信息都是在编译时确定的，所以这些类型的函数调用速度非常快

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

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从成人对象重写（后期绑定）
然后它将从child实现method1，因为在青少年中method1中没有method1

请注意，如果child没有method1，那么main中的代码将无法编译。
编译时多态性也称为重载、早期绑定或静态绑定，当我们有相同的方法名称和不同的行为时。通过实现相同方法的多个原型，其中会出现不同的行为。Early binding指的是程序的第一次编译。
但在后期绑定中，对象是程序中发生的运行时。也称为动态绑定或重写或运行时多态性。
java中最简单的示例：

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

结果是：

Quack
Quack

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

结果是：

Quack
Piiiiiiiiii

早期绑定发生在编译时，而后期绑定发生在运行时。
但是wikipedia关于后期绑定的文章（）说，“后期绑定经常与动态调度混淆，但有显著的区别”。那么它们是否相同？如果它们相同，则需要更改wikipedia页面。更好的答案我知道此答复很旧，并且来源于其他地方，但不准确。后期绑定意味着使用CreateObject，但CreateObject不一定意味着后期绑定。绑定不适用于m实例化一个实例的方法
Quack
Quack

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