Java静态和动态绑定，重载

Question

class Moe {
    public void print(Moe p) {
        System.out.println("Moe 1");
    }
}

class Larry extends Moe {
    public void print(Moe p) {
        System.out.println("Larry 1");
    }
    public void print(Larry l) {
        System.out.println("Larry 2");
    }
}

class Curly extends Larry {
    public void print(Moe p) {
        System.out.println("Curly 1");
    }
    public void print(Larry l) {
        System.out.println("Curly 2");
    }
    public void print(Curly b) {
        System.out.println("Curly 3");
    }
}

class Overloading {
    public static void main (String [] args) {
        Larry stooge1 = new Curly();
        Moe stooge2 = new Larry();
        Moe stooge3 = new Curly();
        Curly stooge4 = new Curly();
        Larry stooge5 = new Larry();

        stooge1.print(new Moe());
        stooge1.print(new Curly());
        stooge1.print(new Larry());
        stooge2.print(new Curly());
        stooge3.print(new Curly());
        stooge3.print(new Larry());
        stooge5.print(new Curly());
    }
}

我想我得到了第一个，但在其他方面我完全迷失了。我是这样解决第一个问题的：

在运行时，stooge1的类型是curly，所以我们调用curly的print方法。因为我们将moe类型的对象传递给print，所以相应的参数类型为moe的print方法在curly中运行。此方法的输出是卷1，正确答案。

然而，当我将此技术应用到以下行时，我最终得到了错误的答案。有人能解释一下这个概念在Java中到底是如何工作的吗？

代码的正确输出是：

Curly 1
Curly 2
Curly 2
Larry 1
Curly 1
Curly 1
Larry 2

Answer 1

静态绑定发生在编译时，动态绑定发生在运行时。

>

静态绑定负责选择应该执行的方法的签名（名称和参数类型）。它使用

• 方法名称
• 包含参数的变量类型（编译器不假设实际对象变量在运行时将包含什么，而是选择能够处理所有可能情况的签名）。

class A {
    public void print(A a) {
        System.out.println("A.print(A)");
    }
}

class B extends A {
    public void print(A a) {
        System.out.println("B.print(A)");
    }
    public void print(B b) {
        System.out.println("B.print(B)");
    }
}

class C extends B {
    public void print(A a) {
        System.out.println("C.print(A)");
    }
    public void print(B b) {
        System.out.println("C.print(B)");
    }
    public void print(C c) {
        System.out.println("C.print(C)");
    }
}

class OverloadingDemo {
    public static void main (String [] args) {
        A ab = new B();
        A ac = new C();
        B bb = new B();
        B bc = new C();

        bc.print(new A());
        bc.print(new C());
        bc.print(new B());
        ab.print(new C());
        ac.print(new C());
        ac.print(new B());
        bb.print(new C());
    }
}

所以，当我们执行

bc.print(new A());

• 静态绑定将尝试在B类中找到最佳的print方法签名，该类可以处理A类型的实例。在本例中，它将是print(A)。
• 之后，动态绑定将在类C中搜索此方法的代码（因为这是由BC变量保存的实例类型），这意味着我们将看到C.print(A).

类似地，bc.print(new C（））；

null