最终静态方法的行为

我一直在使用静态方法修改器，并且遇到了奇怪的行为。

众所周知，静态方法不能被覆盖，因为它们与类而不是实例相关联。

因此，如果我具有以下代码段，则可以正常编译

//Snippet 1 - Compiles fine
public class A {
    static void ts() {
    }
}

class B extends A {
    static void ts() {
    }
}

但是，如果我在类A中包含了对静态方法的final修饰符，则编译失败 ，B中的ts（）无法覆盖A中的ts（）；覆盖的方法是static final。

当根本无法覆盖静态方法时，为什么会发生这种情况？

静态方法不能被覆盖，但是它们可以被隐藏。ts()B 的方法不会覆盖（不会受到多态性的影响）ts()A的方法，但是会隐藏它。如果您ts()以B 调用（NOT A.ts()或B.ts()... just ts()），则将调用B的一个，而不调用A。由于它没有进行多态处理，因此ts()A中的调用将永远不会重定向到B中的一个。

关键字final将禁止隐藏该方法。因此它们不能被隐藏，尝试这样做将导致编译器错误。

希望这可以帮助。

静态方法不能被覆盖

这不是真的。该示例代码实际上意味着B中的ts方法将A中的ts方法隐藏了。因此，它并不是完全覆盖。在Javaranch上有一个很好的解释。

静态方法属于类，而不是实例。

A.ts()并且B.ts()将始终是单独的方法。

真正的问题是Java允许您在实例对象上调用静态方法。从子类的实例调用时，具有父类相同签名的静态方法将被隐藏。但是，您不能覆盖/隐藏final方法。

您会认为错误消息将使用“隐藏”一词，而不是覆盖...

考虑以下因素，您可能会发现自己可以考虑将静态方法定为最终方法：

具有以下课程：

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

现在，调用这些方法的“正确”方法是

A.ts();
B.ts();

这将导致AB但您也可以在实例上调用方法：

A a = new A();
a.ts();
B b = new B();
b.ts();

这也会导致AB。

现在考虑以下几点：

A a = new B();
a.ts();

那会打印出来A。因为您实际上有一个class对象，这可能会让您感到惊讶B。但是由于您是从type的引用中调用它的A，所以它将调用A.ts()。您可以B使用以下代码进行打印：

A a = new B();
((B)a).ts();

在这两种情况下，您拥有的对象实际上都是来自class的B。但是，根据指向对象的指针，您将从A或从调用方法B。

现在，假设您是类的开发人员，A并且想要允许子类化。但是，您真的想要method ts()，无论何时从子类中调用它，这都是您想要的，并且不会被子类版本隐藏。然后，您可以制作它final并防止它被隐藏在子类中。并且您可以确保以下代码将从您的类中调用该方法A：

B b = new B();
b.ts();

好的，诚然，这是经过某种方式构造的，但在某些情况下可能有意义。

您不应在实例上调用静态方法，而应在类上直接调用-这样就不会有问题。另外，例如，如果您在实例上调用静态方法以及将静态方法定为最终方法，则IntelliJ IDEA也会向您显示警告。

B中的ts（）方法不会覆盖A中的ts（）方法，它只是另一种方法。由于B类是静态的，因此它在A中看不到ts（）方法，因此它可以声明自己的方法ts（）。

但是，如果该方法是最终方法，则编译器将发现A中存在ts（）方法，该方法不应在B中覆盖。

我认为编译错误在这里极具误导性。它不应该说“覆盖的方法是static final。”，而应该说“覆盖的方法是final”。静态修饰符在这里无关紧要。

与非静态方法不同，在Java中不能覆盖静态方法。但是它们像静态和非静态数据成员一样被继承。这就是为什么不能在父类中创建具有相同名称的非静态方法的原因

class Writer { 
    public static void doo(){
        System.out.println("sth");
    } 
}
class Author extends Writer{ 
    public void doo(){
        System.out.println("ok"); // error overridden method is static
    }
}

的final关键字确保了特定方法主体运行每次对方法的调用。现在，如果在子类中创建了具有相同名称的静态方法并对其进行了调用，则子类中的方法将被执行，如果final在父类中的静态方法名称之前添加前缀，则情况并非如此。因此，final关键字限制子类中具有相同名称的方法的创建。