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

这是关于它的官方文件:

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

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

根据Java文档:

静态方法是与其中的类相关联的方法 它是定义的，而不是与任何对象。类的每个实例 共享它的静态方法

在Java 8中，除了默认方法外，接口中还允许使用静态方法。这使得我们更容易在库中组织helper方法。我们可以在同一个接口中保留特定于某个接口的静态方法，而不是在一个单独的类中。

一个很好的例子是:

list.sort(ordering);

而不是

Collections.sort(list, ordering);

另一个使用静态方法的例子也在doc中给出:

public interface TimeClient {
    // ...
    static public ZoneId getZoneId (String zoneString) {
        try {
            return ZoneId.of(zoneString);
        } catch (DateTimeException e) {
            System.err.println("Invalid time zone: " + zoneString +
                "; using default time zone instead.");
            return ZoneId.systemDefault();
        }
    }

    default public ZonedDateTime getZonedDateTime(String zoneString) {
        return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
    }    
}

有一种情况是静态和抽象可以一起使用，那就是当这两个修饰符都放在嵌套类的前面时。

我看到已经有无数的答案，但我没有看到任何实际的解决方案。当然，这是一个真正的问题，没有很好的理由在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();
    }

你不能重写静态方法，所以使它抽象是没有意义的。此外，抽象类中的静态方法将属于该类，而不是覆盖类，因此无论如何都不能使用。