因为“抽象”的意思是:“不实现任何功能”，而“静态”的意思是:“即使你没有对象实例，也有功能”。这是一个逻辑矛盾。

这是一个糟糕的语言设计，真的没有理由不可能。

事实上，这里有一个模式或方法可以在**Java中模仿它，让你至少能够修改自己的实现:

public static abstract class Request {                 

        // Static method
        public static void doSomething() {
                get().doSomethingImpl();
        }
        
        // Abstract method
        abstract void doSomethingImpl();

        /////////////////////////////////////////////
        private static Request SINGLETON;
        private static Request get() {
            if ( SINGLETON == null ) {
                // If set(request) is never called prior,
                // it will use a default implementation. 
                return SINGLETON = new RequestImplementationDefault();
            }
            return SINGLETON;
        }
        public static Request set(Request instance){
            return SINGLETON = instance;
        }
        /////////////////////////////////////////////
}

两种实现:

/////////////////////////////////////////////////////

public static final class RequestImplementationDefault extends Request {
        @Override void doSomethingImpl() {
                System.out.println("I am doing something AAA");
        }
}

/////////////////////////////////////////////////////

public static final class RequestImplementaionTest extends Request {
        @Override void doSomethingImpl() {
                System.out.println("I am doing something BBB");
        }
}

/////////////////////////////////////////////////////

可以这样使用:

Request.set(new RequestImplementationDefault());

// Or

Request.set(new RequestImplementationTest());

// Later in the application you might use

Request.doSomething();

这将允许您静态地调用方法，同时还能够更改例如Test环境的实现。

理论上，您也可以在ThreadLocal上执行此操作，并且能够为每个线程上下文设置实例，而不是像这里所示的完全全局，然后可以执行Request。withRequest(anotherRequestImpl，() ->{…})或类似的。

现实世界通常不需要ThreadLocal方法，通常能够全局地改变测试环境的实现就足够了。

请注意，这样做的唯一目的是能够保留静态方法所提供的直接、轻松和干净地调用方法的能力，同时能够切换实现，以牺牲稍微复杂的实现为代价。

它只是一种绕过通常不可修改的静态代码的模式。

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

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

这是关于它的官方文件:

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

根据定义，静态方法不需要知道这些。因此，它不能是一个虚方法(根据通过this获得的动态子类信息重载);相反，静态方法重载仅基于编译时可用的信息(这意味着:一旦引用了父类的静态方法，就调用父类方法，而不调用子类方法)。

根据这一点，抽象静态方法将是非常无用的，因为您永远不会用一些已定义的对象来代替它的引用。

因为“抽象”意味着方法是要被重写的，而不能重写“静态”方法。