java - docs.oracle.com 上有关覆盖和隐藏方法的文本是否含糊不清？

Question

我正在 docs.oracle.com 网站 ( https://docs.oracle.com/javase/tutorial/java/IandI/override.html ) 上阅读有关覆盖和隐藏方法的信息。在“静态方法”标题下，Oracle 为我们总结如下:

“隐藏静态方法和重写实例方法之间的区别具有重要含义:

• 被调用的重写实例方法的版本是子类中的版本。
• 调用的隐藏静态方法的版本取决于它是从父类(super class)还是子类调用。”

第一个要点非常清晰。第二个要点似乎也非常有用，但当我重读它时，我似乎感到困惑。

从我的角度来看，父类(super class)和子类中的每个静态方法似乎都是隐藏的，并且通过早期绑定(bind)(编译时绑定(bind))选择适当的方法并隐藏另一个方法。这是通过调用它的变量的引用类型来选择的。然而，第二个要点中句子的表述使得编译器似乎将这两个方法视为一个方法，因为它们具有相同的签名，并且具有版本 super 和版本 sub，而不是必须分离隐藏方法并选择适当的方法。

我的问题是这两个角度中哪一个是正确的(两种方法都被隐藏，或者一种方法由于方法签名而有两个版本)，我考虑哪一个有关系吗？额外奖励:我对这个主题的总体想法正确吗？

public class Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Animal");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method in Animal");
    }
}

public class Cat extends Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Cat");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method in Cat");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        Animal myAnimal = myCat;
        Animal.testClassMethod();
        myAnimal.testInstanceMethod();
    }
}

//The static method in Animal
//The instance method in Cat

Answer 1

From my perspective it seems like that both static methods in both the superclass and subclass are hidden, and by early-binding (compile-time binding) the appropriate method is chosen and the other one is hidden.

对于下面的内容，请考虑以下代码:

class SuperClass {
    static void a() { System.out.println("SuperClass.a()"); }
    static void b() { System.out.println("SuperClass.b()"); }
    void testSuper() { // Call from "inside" SuperClass
        a(); // calls SuperClass.a()
        b(); // calls SuperClass.b()
    }
}
class SubClass extends SuperClass {
    static void b() { System.out.println("SubClass.b()"); }
    static void c() { System.out.println("SubClass.c()"); }
    void testSub() { // Call from "inside" SubClass
        a();   // calls SuperClass.a().
        b();   // calls SubClass.b().
        c();   // calls SubClass.c()
    }
}
class Test {
    void testSuper() { // Call SuperClass from "outside"
        SuperClass.a(); // calls SuperClass.a()
        SuperClass.b(); // calls SuperClass.b()
    }
    void testSub() { // Call SubClass from "outside"
        SubClass.a(); // calls SuperClass.a()
                      // IDE warning: The static method a() from the type SuperClass should be accessed directly
        SubClass.b(); // calls SubClass.b()
        SubClass.c(); // calls SubClass.c()
    }
}

有两种情况需要考虑:

• 两个 testSuper() 方法:从“内部”SuperClass 调用方法，或通过使用 SuperClass 限定从“外部”调用方法。

  在这种情况下，没有隐藏任何内容。您可以在SuperClass中调用a()和b()。

  SubClass 中的方法不被视为隐藏，因为它们显然不在范围内。

• 两个 testSub() 方法:从“内部”SubClass 调用方法，或通过使用 SubClass 限定从“外部”调用方法。

  在本例中，所有 4 个方法都在作用域内，但 SuperClass 中的 b() 方法被隐藏。

如您所见，只有 SuperClass 中的 b() 被认为是隐藏的。 SubClass 中的 b() 永远不会隐藏。