关于Java重载和动态绑定的问题

Question

在下面的代码中,第一个和第二个打印语句如何打印出SubObj？顶部和子指向同一个Sub类吗？

class Top {
    public String f(Object o) {return "Top";}
}

class Sub extends Top {
    public String f(String s) {return "Sub";}
    public String f(Object o) {return "SubObj";}
}

public class Test {
    public static void main(String[] args) {  
        Sub sub = new Sub();
        Top top = sub;
        String str = "Something";
        Object obj = str;


        System.out.println(top.f(obj));
        System.out.println(top.f(str));
        System.out.println(sub.f(obj));
        System.out.println(sub.f(str));
    }
}

以上代码返回以下结果.

SubObj
SubObj
SubObj
Sub

Answer 1

既然您已经了解了案例1,3和4,那么让我们解决案例2.

(请注意 - 我绝不是JVM或编译器内部工作方面的专家,但这是我理解它的方式.如果有人读这篇文章是JVM专家,请随时编辑这个答案,你可能会发现任何差异.)

子类中具有相同名称但签名不同的方法称为方法重载.方法重载使用静态绑定,这基本上意味着在编译时强制适当的方法被"选择"(即绑定).编译器不知道对象的运行时类型(也就是实际类型).所以当你写:

                         // Reference Type  // Actual Type
    Sub sub = new Sub(); // Sub                Sub
    Top top = sub;       // Top                Sub

编译器只"知道"top是Top类型(也就是引用类型).所以当你后来写:

    System.out.println(top.f(str)); // Prints "subobj"

编译器"看到"调用'top.f'作为引用Top类的f方法.它"知道"str是String类型,它扩展了Object.因此,1)调用'top.f'引用Top类的f方法,2)类Top中没有f方法接受String参数,3)因为str是Object的子类,Top类的f方法是编译时唯一有效的选择.因此编译器隐式地将str向上转换为其父类型Object,因此可以将其传递给Top的f方法.(这与动态绑定形成对比,其中上述代码行的类型解析将推迟到运行时,由JVM而不是编译器解析.)

然后在运行时,在上面的代码行中,top被JVM向下转换为它的实际类型sub.但是,参数str已由编译器向上转换为Object类型.所以现在JVM必须在class sub中调用一个带有Object类型参数的f方法.

因此,上面的代码行打印"subobj"而不是"sub".

有关另一个非常类似的示例,请参阅:Java动态绑定和方法覆盖

更新:发现这篇关于JVM内部工作原理的详细文章:

http://www.artima.com/underthehood/invocationP.html

我评论了你的代码,以便更清楚地了解发生了什么:

class Top {
    public String f(Object o) {return "Top";}
}

class Sub extends Top {
    public String f(String s) {return "Sub";} // Overloading = No dynamic binding
    public String f(Object o) {return "SubObj";} // Overriding = Dynamic binding
}

public class Test {
    public static void main(String[] args) {  

                                  // Reference Type     Actual Type
        Sub sub = new Sub();      // Sub                Sub
        Top top = sub;            // Top                Sub
        String str = "Something"; // String             String
        Object obj = str;         // Object             String

                                        // At Compile-Time:      At Run-Time:
        // Dynamic Binding
        System.out.println(top.f(obj)); // Top.f (Object)   -->  Sub.f (Object)

        // Dynamic Binding
        System.out.println(top.f(str)); // Top.f (Object)   -->  Sub.f (Object)

        // Static Binding
        System.out.println(sub.f(obj)); // Sub.f (Object)        Sub.f (Object)

        // Static Binding
        System.out.println(sub.f(str)); // Sub.f (String)        Sub.f (String)
    }
}

Answer 2

这是因为Java中的所有方法调用都是虚拟的(默认情况下).

也就是说,分辨率从实际对象(不是表达式的类型)开始,并"继续"继承链(根据实际对象类型),直到找到第一个匹配方法.非虚方法将从表达式开始.(将方法标记final为非虚拟.)

但是,确切的方法签名是在编译时确定的(Java不支持多分派,单分派仅在运行时根据接收者对象而变化) - 这解释了为什么Sub.f(String)结果为"Sub",例如while 即使在TOP的子类型上调用,也Top.f(String)"绑定"到方法匹配Top.f(Object).(这是在编译时确定的最佳合格签名).虚拟调度本身也是一样的.

快乐的编码.