在一行中，这种危险的组合(抽象+静态)违反了面向对象的原则，即多态性。

在继承情况下，JVM将在运行时根据实现决定实例的类型(运行时多态性)，而不是根据引用变量的类型(编译时多态性)。

@Overriding:

静态方法不支持@ override(运行时多态性)，而只支持方法隐藏(编译时多态性)。

@Hiding:

但是在抽象静态方法的情况下，父(抽象)类没有方法的实现。因此，子类型引用是唯一可用的，而且它不是多态性。

子引用是唯一可用的:

出于这个原因(抑制oop特性)，Java语言认为抽象+静态是非法(危险)的方法组合。

方法的抽象注释表明该方法必须在子类中重写。

在Java中，静态成员(方法或字段)不能被子类覆盖(在其他面向对象语言中不一定是这样，请参阅SmallTalk)。静态成员可能被隐藏，但这与被覆盖有本质区别。

由于静态成员不能在子类中被重写，因此抽象注释不能应用于它们。

顺便说一句，其他语言确实支持静态继承，就像实例继承一样。从语法的角度来看，这些语言通常要求在语句中包含类名。例如，在Java中，假设你在ClassA中编写代码，这是等价的语句(如果methodA()是一个静态方法，并且没有具有相同签名的实例方法):

ClassA.methodA();

and

methodA();

在SmallTalk中，类名不是可选的，所以语法是(注意，SmallTalk不使用。将“主语”和“动词”分开，而是将其用作语句结束符):

ClassA methodA.

因为总是需要类名，所以总是可以通过遍历类层次结构来确定方法的正确“版本”。无论如何，我偶尔会错过静态继承，当我第一次开始使用Java时，我就被Java中缺乏静态继承所困扰。此外，SmallTalk是duck类型的(因此不支持契约式编程)。因此，类成员没有抽象修饰符。

您可以使用Java 8中的接口来实现这一点。

这是关于它的官方文件:

https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

我看到已经有无数的答案，但我没有看到任何实际的解决方案。当然，这是一个真正的问题，没有很好的理由在Java中排除这种语法。由于最初的问题缺乏上下文，因此我提供了上下文和解决方案:

假设你在一堆相同的类中有一个静态方法。这些方法调用特定于类的静态方法:

class C1 {
    static void doWork() {
        ...
        for (int k: list)
            doMoreWork(k);
        ...
    }
    private static void doMoreWork(int k) {
        // code specific to class C1
    }
}
class C2 {
    static void doWork() {
        ...
        for (int k: list)
            doMoreWork(k);
        ...
    }
    private static void doMoreWork(int k) {
        // code specific to class C2
    }
}

C1和C2中的doWork()方法相同。可能有很多这样的类:C3 C4等。如果允许静态抽象，你可以通过这样做来消除重复代码:

abstract class C {
    static void doWork() {
        ...
        for (int k: list)
            doMoreWork(k);
        ...
    }

    static abstract void doMoreWork(int k);
}

class C1 extends C {
    private static void doMoreWork(int k) {
        // code for class C1
    }
}

class C2 extends C {
    private static void doMoreWork(int k) {
        // code for class C2
    }
}

但这将无法编译，因为静态抽象组合是不允许的。 然而，这可以通过静态类构造来避免，这是允许的:

abstract class C {
    void doWork() {
        ...
        for (int k: list)
            doMoreWork(k);
        ...
    }
    abstract void doMoreWork(int k);
}
class C1 {
    private static final C c = new  C(){  
        @Override void doMoreWork(int k) {
            System.out.println("code for C1");
        }
    };
    public static void doWork() {
        c.doWork();
    }
}
class C2 {
    private static final C c = new C() {
        @Override void doMoreWork(int k) {
            System.out.println("code for C2");
        }
    };
    public static void doWork() {
        c.doWork();
    }
}

使用此解决方案，唯一重复的代码是

    public static void doWork() {
        c.doWork();
    }

因为如果一个类扩展了一个抽象类，那么它必须重写抽象方法，这是强制性的。由于静态方法是在编译时解析的类方法，而覆盖方法是在运行时解析的实例方法，并遵循动态多态性。

我也问了同样的问题，原因如下

因为抽象类说，它不会给出实现，并允许子类给出它

所以子类必须重写超类的方法，

规则1 -静态方法不能被覆盖

因为静态成员和方法是编译时元素，这就是为什么允许重载(编译时多态性)静态方法而不是重写(运行时多态性)

所以它们不可能是抽象的。

Java宇宙中不允许有抽象静态<——之类的东西