虽然多态的主要原则是在 types 方面解耦“what from who”，但让我感到困惑的是，方法调用机制如何在多态中找出并调用正确的方法体。

因为在 Java 中，所有方法绑定(bind)都是后期绑定(bind)，除非方法是static、final 或private ，后期绑定(bind)由 JVM 完成，它为每个类预先计算方法表，然后在正常方法调用的运行时进行表查找。

但是在多态性期间也会发生同样的事情。例如

假设我有一个带有 ride() 方法的通用类 Cycle

class Cycle {

    public void ride(){
        System.out.println("I'm Riding generic Cycle()");
    }

}

我有三个专用类 Bicycle Tricycle 和 Unicycle 扩展了通用类 Cycle 并覆盖了它的 ride() 方法。

class Bicycle extends Cycle {

    public void ride() {
        System.out.println("I'm riding Bicycle");

    }

}

class Tricycle extends Cycle{

    public void ride() {
        System.out.println("I'm riding Tricycle ");

    }

}

class Unicycle extends Cycle {

    public void ride() {
        System.out.println("I'm Riding Unicycle ");

    }

}

这是用于测试上述多态性的 TestRide 类。

public class TestRide {

    public static void ride(Cycle c){
        c.ride();
    }

    public static void main(String[] args){

        Cycle Cycling = new Cycle();
        ride(Cycling);

        Bicycle bi = new Bicycle();
        ride(bi);

        Tricycle tri = new Tricycle();
        ride(tri);

        Unicycle uni = new Unicycle();
        ride(uni);
    }

}

输出是

I'm Riding generic Cycle()
I'm riding Bicycle
I'm riding Tricycle 
I'm Riding Unicycle 

字节码:

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         0: new           #17                 // class com/polymorphism/Cycle
         3: dup
         4: invokespecial #24                 // Method com/polymorphism/Cycle."
<init>":()V
         7: astore_1
         8: aload_1
         9: invokestatic  #25                 // Method ride:(Lcom/polymorphism/
Cycle;)V
        12: new           #27                 // class com/polymorphism/Bicycle
        15: dup
        16: invokespecial #29                 // Method com/polymorphism/Bicycle
."<init>":()V
        19: astore_2
        20: aload_2
        21: invokestatic  #25                 // Method ride:(Lcom/polymorphism/
Cycle;)V
        24: new           #30                 // class com/polymorphism/Tricycle

        27: dup
        28: invokespecial #32                 // Method com/polymorphism/Tricycl
e."<init>":()V
        31: astore_3
        32: aload_3
        33: invokestatic  #25                 // Method ride:(Lcom/polymorphism/
Cycle;)V
        36: new           #33                 // class com/polymorphism/Unicycle

        39: dup
        40: invokespecial #35                 // Method com/polymorphism/Unicycl
e."<init>":()V
        43: astore        4
        45: aload         4
        47: invokestatic  #25                 // Method ride:(Lcom/polymorphism/
Cycle;)V
        50: return

即使在字节码中，它也像往常一样使用 invokestatic 和 invokespecial 调用方法，而我认为它会使用 invokedynamic 来确定版本适合对象实际类型的方法。但事实并非如此。

那么，当我们只是在 ride() 方法中像 ride(bi) 一样在 >TestRide 类 ?

编辑:RIDE 方法字节码

public static void ride(com.polymorphism.Cycle);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokevirtual #16                 // Method com/polymorphism/Cycle.r
ide:()V
         4: return

最佳答案

首先 invokedynamic 是针对 Java 8 lambda 和非 Java 代码的，所以你可以忘记它。

除此之外，还有四个调用指令(invokespecial、invokestatic、invokevirtual 和invokeinterface) .您可以在 JVM 规范中看到精确的语义，但底线是 invokevirtual 和 invokeinterface 是虚拟方法调用，即实际方法调用是在运行时根据目标的具体类型选择的。

代码中唯一的虚拟调用是在 TestRide.ride 中。列出的目标是 Cycle.ride:()V。然而，由于它是一个虚拟调用，JVM 将在运行时检查第一个参数的实际类型并调用该方法的最派生版本。

这类似于 C++ 中的虚拟方法调用，除了 JVM 和 JIT 编译的抽象允许实现更优化的潜力。

另请注意，不要将其与方法重载相混淆，方法重载是编译时多态性的一种形式。对于重载方法，编译器根据参数的编译时类型选择调用哪一个。

关于java - Java如何在多态中确定运行时调用的方法？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32678928/