编译时每运行次绑定都是静态绑定是真的吗？

Question

我对主题绑定很困惑。正如我们所知，在静态绑定中，通过检查引用的类型来确定绑定，而不是它所引用的对象，而在动态绑定中，将考虑引用指向的对象类型。

class A
{
    void show()
    {
        System.out.println("From A");
    }
}
class B extends A
{
    void show()
    {
        System.out.println("From B");
    }
}
class Main
{
    public static void main(String[] quora)
    {
        A a1 = new A();
        A a2 = new B();

        a1.show(); //line 1
        a2.show(); //line 2
    }
}

在上面的示例中，我们可以看到在编译期间，Line1 和 line2 都将被静态绑定处理，它们将 link 到 A-class 方法 show( 因为类型参考文献是 A)。但是在运行时间内，调用被解析并且第 1 link 行到 A-class 方法 show() 和第 2 link 行到 B-class 方法，即对象的类型，或者我们可以说是动态绑定。

所以我的主要目的是了解以下内容。

动态绑定总是在静态绑定之后产生的吗？或者我理解错了什么？
如果它是真的那么说每个方法在运行时间内都是动态 linked 是真的吗？
我们可以概括一下吗？

Answer 1

基本上，每次您调用方法时，编译器都必须根据您传递给该方法的类型和参数来确定要调用哪个 overload。这是静态绑定。然后在运行时，运行时将找出要调用重载的哪个实现（此时已经确定）。

考虑：

class A
{
    void f(Object o)
    {
        System.out.println("From A");
    }
}
class B extends A
{

    void f(Object o)
    {
        System.out.println("From B (Object)");
    }

    void f(String s)
    {
        System.out.println("From B (String)");
    }
}

而你这样做：

A a = new B();
a.f("");

会发生什么？在编译时，由于 a 的类型是 A，编译器选择了重载 f(Object)（只有一种方法可供选择！）。然后在运行时，由于 a 实际上引用 B 的实例，B 的 f(Object) 重载实现被调用，打印 From B (Object)。我见过的一种误解是期望输出为 From B (String)。这是错误的，因为编译器不知道 a.

上存在这个重载

Is dynamic binding always results after static binding?

从上面代码的结果我们可以看出，答案是肯定的。静态绑定发生在编译时，动态绑定发生在运行时，所以前者总是先发生。

If it's true then is it true to say every method is dynamically linked during the run time?

我不确定你的意思，所以希望上面的详细解释已经回答了这个问题。

no matter what, there's always gonna be static binding and then dynamic binding for every method call?

是的，但有时这两个过程会进行得很快，因为选择很少。当您调用方法的 class 是最终的 class 时，您可能不需要在动态绑定中创建 "choice"，对吗？

编译时每运行次绑定都是静态绑定是真的吗？

Is it true to say that every run time binding was a static binding during compilation?

java

polymorphism

overriding

overloading

static-polymorphism