Java动态绑定技术问题：代码输出76的原因解析

class A {
    public int m(A p) {
        return 12;
    }

    public int n(A p) {
        return 38;
    }
}
class B extends A {
    public int m(B p) {
        return 3;
    }

    public int n(A p) {
        return 7;
    }
}

class C extends A {
    public int m(A p) {
        return 38;
    }
    public int n(A p) {
        return 4;
    }
}
class D extends A {
    public int m(A p) {
        return 1;
    }

    public int n(D p) {
        return 2;
    }
}
class Main {
    public static void main(String argv[]) {
        A x = new C();
        A y = new D();
        D z = new D();
        System.out.println(x.m(z) + y.n(z)); // 输出76
    }
}

1. x.m(z)的执行逻辑 #

x的静态类型是A，编译时编译器会匹配A中参数兼容z（D是A子类）的m方法，即A.m(A p)。运行时因为x实际是C实例，且C重写了A.m(A p)，所以调用C.m(A p)，返回38。

2. y.n(z)的执行逻辑 #

y的静态类型是A，编译时匹配A.n(A p)（z是A子类，参数兼容）。运行时y实际是D实例，但D的n(D p)是方法重载（参数类型和A.n(A p)不同，方法签名不一致），并没有重写父类的n(A p)，因此调用A.n(A p)，返回38。

最终计算 #

38 + 38 = 76，这就是输出结果的由来。

核心依赖机制 #

• 方法重载：编译阶段根据方法参数的静态类型确定调用哪个方法，属于静态绑定。
• 方法重写：运行阶段根据对象的实际类型确定调用哪个方法，属于动态绑定。只有方法签名（方法名、参数类型及数量）完全一致的方法才会被视为重写，否则是重载。

内容的提问来源于stack exchange，提问作者How to