重写依赖于类的实例。多态性的意义在于，您可以子类化一个类，而实现这些子类的对象对于父类中定义的相同方法将具有不同的行为(并且在子类中被重写)。静态方法不与类的任何实例相关联，因此这个概念不适用。

There were two considerations driving Java's design that impacted this. One was a concern with performance: there had been a lot of criticism of Smalltalk about it being too slow (garbage collection and polymorphic calls being part of that) and Java's creators were determined to avoid that. Another was the decision that the target audience for Java was C++ developers. Making static methods work the way they do had the benefit of familiarity for C++ programmers and was also very fast, because there's no need to wait until runtime to figure out which method to call.

重写是为实例成员保留的，以支持多态行为。静态类成员不属于特定实例。相反，静态成员属于类，因此不支持重写，因为子类只继承受保护和公共实例成员，而不继承静态成员。您可能希望定义一个接口，并研究工厂和/或策略设计模式，以评估替代方法。

Yes. Practically Java allows overriding static method, and No theoretically if you Override a static method in Java then it will compile and run smoothly but it will lose Polymorphism which is the basic property of Java. You will Read Everywhere that it is not possible to try yourself compiling and running. you will get your answer. e.g. If you Have Class Animal and a static method eat() and you Override that static method in its Subclass lets called it Dog. Then when wherever you Assign a Dog object to an Animal Reference and call eat() according to Java Dog's eat() should have been called but in static Overriding Animals' eat() will Be Called.

class Animal {
    public static void eat() {
        System.out.println("Animal Eating");
    }
}

class Dog extends Animal{
    public static void eat() {
        System.out.println("Dog Eating");
    }
}

class Test {
    public static void main(String args[]) {
       Animal obj= new Dog();//Dog object in animal
       obj.eat(); //should call dog's eat but it didn't
    }
}


Output Animal Eating

According to Polymorphism Principle of Java, the Output Should be Dog Eating. But the result was different because to support Polymorphism Java uses Late Binding that means methods are called only at the run-time but not in the case of static methods. In static methods compiler calls methods at the compile time rather than the run-time, so we get methods according to the reference and not according to the object a reference a containing that's why You can say Practically it supports static overring but theoretically, it doesn't.

重写静态方法有什么好处呢?不能通过实例调用静态方法。

MyClass.static1()
MySubClass.static1()   // If you overrode, you have to call it through MySubClass anyway.

编辑:似乎由于语言设计中的一个不幸疏忽，您可以通过实例调用静态方法。一般没人会这么做。我的坏。

这个问题的答案很简单，标记为静态的方法或变量只属于类，因此静态方法不能在子类中继承，因为它们只属于超类。

一般来说，允许“重写”静态方法是没有意义的，因为没有好的方法来确定在运行时调用哪个方法。以Employee为例，如果我们调用regularemploee . getbonusmultiplier()——应该执行哪个方法?

以Java为例，人们可以想象这样一种语言定义:只要静态方法是通过对象实例调用的，就可以“覆盖”它们。然而，这样做只是重新实现常规的类方法，在没有真正带来任何好处的情况下为语言增加冗余。