直接调用子 class 的对象时的静态和私有方法行为听起来像是覆盖？

Question

public class B extends A{

    public static void main(String[] args) {
    new B().privateMethod();//no error -output B-privateMethod.Sounds like overriding
    new B().staticMethod(); //no error -output B-StaticMethod.Sounds like overriding
    }

    private void privateMethod() {
        System.out.println("B-privateMethod.");
    }
    static void staticMethod() {
        System.out.println("B-StaticMethod.");
    }
}


class A{
    private void privateMethod() {
        System.out.println("A-privateMethod.");
    }
    static void staticMethod() {
        System.out.println("A-StaticMethod.");
    }
}

在研发中我发现了 privateMethod() 的情况——因为这个方法在子 class 的对象上不可用所以子 class 和父 class 的 privateMethod () 是单独的方法，它们没有关系，所以这不是最重要的。但是在 staticMethod() 的情况下-父 class 的方法在子对象 class 上可用，当我们在子对象 class 中定义它时，子对象class 开始指向子 class method.this 看起来像方法覆盖但不是，因为静态方法不覆盖。

java开发包如何处理静态方法？

Answer 1

new B().privateMethod();

这不是最重要的，因为 B 没有看到 A 的 privateMethod()。

new B().staticMethod();

这不是覆盖，允许通过实例调用静态方法，尽管它可能会造成混淆。这与通过 class 名称调用它完全相同 - B.staticMethod()。如果 B 的超级 class A 有一个从 B 可见的静态方法，你可以从 B 调用那个方法（如果你写 B.staticMethod() 或 A.staticMethod() 或 new B().staticMethod()。

如果以后在B中定义同名的静态方法，该方法会隐藏A中的同名方法，所以调用B.staticMethod()或new B().staticMethod() 现在调用 B 的静态方法。但是，调用 A.staticMethod() 仍会调用 A 的静态方法。

Answer 2

多态不适用于静态方法。静态方法通过 JVM 指令 invokestatic 调用，而多态性通过 invokevirtual 实现。对静态方法的调用在编译时确定，而多态方法在运行时动态调度。

您可以轻松调整您的代码，以便调用 A.staticMethod()，只需将 new B() 分配给类型 A 的变量即可。

public static void main(String[] args) {
    new B().privateMethod();
    A b = new B(); // change here.
    b.staticMethod(); // A.staticMethod() is called here. 
}

Answer 3

永远不要在同一句话中提到 static 和 override。

可重写方法的整个概念是在运行时动态绑定要执行的方法。考虑一下：

class A { void print() { out.println("A"); }
class B extends A { void print() { out.println("B"); }

A obj = new B();
obj.print();

虽然变量obj的类型是A，但还是打印出"B".

另一方面，静态方法在编译时绑定。这意味着编译器使用变量（或表达式）的类型来确定要执行的方法：

class A { static void print() { out.println("A"); }
class B extends A { static void print() { out.println("B"); }

A obj = new B();
obj.print();

这现在产生 "A"。不幸的是，Java 语言允许在变量或表达式上调用静态方法。不推荐这样做！最好在类型本身上调用静态方法：

A.print();
B.print();

在第一个示例中 - obj.print(); - 编译器自动将语句翻译成 A.print()。实际对象不算数。事实上你可以这样写：

A obj = null;
obj.print();

或：

((A) null).print();

仍然打印 "A"。

直接调用子 class 的对象时的静态和私有方法行为听起来像是覆盖？

static and private method behavior when calling direct on object of child class sounds like overriding?

java

static

overriding

private

access-specifier