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

事实上，这里有一个模式或方法可以在**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();
    }

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

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

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

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

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

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

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

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

使用抽象静态方法的想法是，您不能直接为该方法使用特定的抽象类，但只允许一阶导数实现该静态方法(或者对于泛型:您使用的泛型的实际类)。

通过这种方式，您可以创建sortableObject抽象类甚至接口 使用(auto-)抽象静态方法，定义排序选项的参数:

public interface SortableObject {
    public [abstract] static String [] getSortableTypes();
    public String getSortableValueByType(String type);
}

现在你可以定义一个可排序对象，它可以根据所有这些对象的主要类型进行排序:

public class MyDataObject implements SortableObject {
    final static String [] SORT_TYPES = {
        "Name","Date of Birth"
    }
    static long newDataIndex = 0L ;

    String fullName ;
    String sortableDate ;
    long dataIndex = -1L ;
    public MyDataObject(String name, int year, int month, int day) {
        if(name == null || name.length() == 0) throw new IllegalArgumentException("Null/empty name not allowed.");
        if(!validateDate(year,month,day)) throw new IllegalArgumentException("Date parameters do not compose a legal date.");
        this.fullName = name ;
        this.sortableDate = MyUtils.createSortableDate(year,month,day);
        this.dataIndex = MyDataObject.newDataIndex++ ;
    }
    public String toString() {
        return ""+this.dataIndex+". "this.fullName+" ("+this.sortableDate+")";
    }

    // override SortableObject 
    public static String [] getSortableTypes() { return SORT_TYPES ; }
    public String getSortableValueByType(String type) {
        int index = MyUtils.getStringArrayIndex(SORT_TYPES, type);
        switch(index) {
             case 0: return this.name ;
             case 1: return this.sortableDate ;
        }
        return toString(); // in the order they were created when compared
    }
}

现在您可以创建一个

public class SortableList<T extends SortableObject> 

它可以检索类型，构建一个弹出菜单来选择要排序的类型，并通过从该类型获取数据来返回列表，以及hainv一个add函数，当选择了排序类型时，可以自动对新项进行排序。 注意SortableList实例可以直接访问“T”的静态方法:

String [] MenuItems = T.getSortableTypes();

必须使用实例的问题是SortableList可能还没有项目，但已经需要提供首选排序。

再见 奥拉夫。

静态方法可以在没有类实例的情况下调用。在你的例子中，你可以调用foo.bar2()，但不能调用foo.bar()，因为bar需要一个实例。 以下代码将工作:

foo var = new ImplementsFoo();
var.bar();

如果您调用一个静态方法，它将始终执行相同的代码。在上面的例子中，即使你在ImplementsFoo中重新定义了bar2，调用var.bar2()也会执行foo.bar2()。

如果bar2现在没有实现(这就是抽象的意思)，您可以调用没有实现的方法。这是非常有害的。