java多态后期绑定(bind)规则

Question

我正在尝试做一些多态性练习，但我无法弄清楚这种多态性是如何工作的。我没有找到任何关于这种练习的深入信息。希望大家能给我一些解释。

练习1:

class Top {
    public void m( Middle p ) System.out.print("A ");
}

class Middle extends Top {
    public void m( Object p ) System.out.print("M ");
    public void m( Middle p ) System.out.print("L ");
}

class Bottom extends Middle {
    public void m( Object p ) System.out.print("V ");
    public void m( Middle p ) System.out.print("X ");
}

class Test {
    public static void run() {
        Top tm = new Middle();
        Middle mb = new Bottom();

        tm.m (mb);            -> L
        tm.m(new Bottom());   -> L   why?
        mb.m(mb);             -> X
        mb.m(tm);             -> V   why?
        mb.m(new Middle());   -> X
        new Bottom().m(tm);   -> V
    }
}

练习2:

class Top {
    public void gg( Top o ) System.out.print("A ");
    public void gg( Middle m ) System.out.print("B ");
}

class Middle extends Top {
    public void gg( Top o ) System.out.print("L ");
    public void gg( Bottom b ) System.out.print("M ");
}

class Bottom extends Middle {
    public void gg( Top o ) System.out.print("X ");
    public void gg( Middle m) System.out.print("Z ");
}

class Test {
    public static void run() {
        Top oo = new Top();
        Top ff = new Middle();
        Bottom uu = new Bottom();

        oo.gg(ff);      -> A
        oo.gg(uu);      -> A   why?
        ff.gg(ff);      -> L
        ff.gg(uu);      -> B   why?
        uu.gg(ff);      -> X
        uu.gg(uu);      -> X   why?
    }
}

提前谢谢您!

问候

Answer 1

在所有这些情况下，可以考虑的方法取决于变量的编译时类型，但实际调用的方法取决于对象的运行时类型。所以对于

Top ff = new Middle();

将调用 Middle 的方法 - 但这些方法可能是从 Top 继承的，并且我们只能在编译时调用 Top 中可用的方法时间，因为 ff 被声明为 Top。

为了确定调用哪个重载方法，我们查看参数类型，并选择最具体的方法。因此，如果我们必须选择:

public void m( Object p ) System.out.print("M ");
public void m( Middle p ) System.out.print("L ");

并且我们传递一个Bottom，那么将选择第二种方法。您可以将类层次结构中的 Bottom 视为比 Object 更接近于 Middle:

Bottom -> Middle -> Top -> Object

最后，您的一些答案是错误的(练习 2) - 我建议您尝试运行代码，这可能需要一些调整才能真正编译。

oo.gg(uu); // -> A why?  -- actually produces B
uu.gg(uu); // -> X why?  -- actually produces M