Programming languages 静态绑定和动态绑定之间有什么区别？

绑定时间可以分为两种类型：静态和动态。静态绑定和动态绑定之间有什么区别

---

您能给出一个简单的例子来进一步说明吗？

在最一般的术语中，静态绑定意味着在编译时解析引用

动态绑定意味着在运行时解析引用

---

它取决于绑定发生的时间：编译时（静态）或运行时（动态）。调用简单类方法时使用静态绑定。当您开始处理类层次结构和虚拟方法时，编译器将开始使用所谓的s。那时，编译器不知道要调用什么方法，它必须等到运行时才能找到要调用的正确方法（这是通过）。这称为动态绑定

---

有关更多详细信息和参考信息，请参阅上的Wikipedia文章。

编译时完成的绑定是静态绑定，运行时完成的绑定是动态绑定。在静态绑定中，指针的数据类型决定调用哪个方法。但在动态绑定中，对象的数据类型决定调用哪个方法。

*执行时间：-*将变量绑定到其值，以及在执行时将变量绑定到特定存储位置称为执行时绑定

它可能有两种类型

进入子程序时

在执行期间的任意点

编译时绑定：-（翻译时） 它包括以下内容

由程序员选择的绑定

由译者选择的装订

由加载程序选择的绑定

---

我得到了quora用户“Monis Yousuf”的完美答案。他解释得很好。我把它放在这里是为了其他人

绑定在面向对象编程中主要是一个与多态性相关的概念

首先，了解什么是多态性。书上说它的意思是“一个名字和多种形式”。没错，但太抽象了。让我们举一个真实的例子。你去看“医生”，医生可能是眼科专家、耳鼻喉科专家、神经外科医生、顺势疗法等

这里，“医生”是一个名字，可能有多种类型；每一个都执行自己的功能。这就是现实生活中的多态性

函数重载：这个概念描述了静态绑定。函数重载可以大致定义为，两个或多个具有相同名称但签名不同（包括参数数量、参数类型、不同返回类型）的方法（函数）称为重载方法（或函数）

假设您必须计算矩形和圆形的面积。见以下代码：-

class CalculateArea {

    private static final double PI = 3.14;

    /* 
       Method to return area of a rectangle 
       Area of rectangle = length X width
    */
    double Area(double length, double width) {
        return (length * width);
    }

    /*
      Method to return area of circle
      Area of circle = π * r * r
    */
    double Area(double radius) {
        return PI * radius * radius;
    }
}

在上面的代码中，有两种不同参数的“区域”方法。此场景符合函数重载的条件

现在，进入真正的问题：静态绑定是如何实现的

在代码中调用上述任何函数时，必须指定要传递的参数。在此场景中，您将通过以下任一步骤：

• double[类型的两个参数将调用第一个方法 计算矩形的宽度]
• double类型的单个参数[将调用第二种方法，以计算圆的面积]

因为java编译器在编译时可以确定调用哪个函数，所以它是编译时（或静态）绑定

函数重写：函数重写是一个在继承中显示的概念。它可以粗略地定义为：当父类中存在一个方法，并且其子类也具有具有相同签名的相同方法时，称为函数重写。[还有更多内容，但为了简单起见，我编写了这个定义]使用下面的代码更容易理解

class ParentClass {
    int show() {
        System.out.println("I am from parent class");
    }
}

class ChildClass extends ParentClass{
    int show() {
        System.out.println("I am from child class");
    }
}

class SomeOtherClass {
    public static void main (String[] s) {
        ParentClass obj = new ChildClass();
        obj.show();
    }
}

在上面的代码中，方法

show（）

被重写，因为父类和子类中都存在相同的签名（和名称）

在第三个类中，

SomeOtherClass

，类型为

ParentClass

的引用变量（obj）持有ChildClass的对象。接下来，从同一参考变量（obj）调用方法

show（

）

同样的问题是：这种动态绑定是如何实现的

在编译时，编译器检查引用变量的类型是否为

ParentClass

，并检查该类中是否存在方法

show（）

。一旦检查了这一点，编译就成功了

现在，当程序运行时，它看到对象是

ChildClass

，因此，它运行

ChildClass

的

show（）

方法。由于此决定是在运行时做出的，因此称之为动态绑定（或运行时多态性）

---

对于原始答案，静态绑定：是在编译时解析类型、成员和操作的过程。 例如：

Car car = new Car();
car.Drive();

dynamic d = new Car();
d.Drive();

在本例中，编译器通过查找

car

对象上的无参数

Drive

方法进行绑定。如果没有找到那个方法！搜索采用的方法，如果未找到该方法，则再次搜索该方法的

Car

，如果未找到该方法，则再次搜索

Car

类型。如果没有找到匹配项，您将得到编译错误

在这种情况下，绑定是由编译器完成的，绑定依赖于静态地知道对象的类型。这使得它成为静态绑定

动态绑定：动态绑定将绑定（解析类型、成员和操作的过程）从编译时推迟到运行时。 例如：

Car car = new Car();
car.Drive();

dynamic d = new Car();
d.Drive();

动态类型告诉编译器我们希望运行时类型

d

具有

Drive

方法，但我们不能