不能在接口中定义静态方法，因为静态方法属于类而不是类的实例，而接口不是类。点击这里阅读更多。

然而，如果你愿意，你可以这样做:

public class A {
  public static void methodX() {
  }
}

public class B extends A {
  public static void methodX() {
  }
}

在这种情况下，你有两个类，两个不同的静态方法称为methodX()。

一个接口永远不能被静态地解引用，例如issomething .member。接口总是通过引用该接口子类实例的变量来解除引用。因此，如果没有其子类的实例，接口引用永远不可能知道它引用的是哪个子类。

Thus the closest approximation to a static method in an interface would be a non-static method that ignores "this", i.e. does not access any non-static members of the instance. At the low-level abstraction, every non-static method (after lookup in any vtable) is really just a function with class scope that takes "this" as an implicit formal parameter. See Scala's singleton object and interoperability with Java as evidence of that concept. And thus every static method is a function with class scope that does not take a "this" parameter. Thus normally a static method can be called statically, but as previously stated, an interface has no implementation (is abstract).

Thus to get closest approximation to a static method in an interface, is to use a non-static method, then don't access any of the non-static instance members. There would be no possible performance benefit any other way, because there is no way to statically link (at compile-time) a ISomething.member(). The only benefit I see of a static method in an interface is that it would not input (i.e. ignore) an implicit "this" and thus disallow access to any of the non-static instance members. This would declare implicitly that the function that doesn't access "this", is immutate and not even readonly with respect to its containing class. But a declaration of "static" in an interface ISomething would also confuse people who tried to access it with ISomething.member() which would cause a compiler error. I suppose if the compiler error was sufficiently explanatory, it would be better than trying to educate people about using a non-static method to accomplish what they want (apparently mostly factory methods), as we are doing here (and has been repeated for 3 Q&A times on this site), so it is obviously an issue that is not intuitive for many people. I had to think about it for a while to get the correct understanding.

在接口中获取可变静态字段的方法是在接口中使用非静态getter和setter方法，来访问子类中的静态字段。旁注，显然不可变静态可以在带有静态final的Java接口中声明。

如果没有泛型，静态接口是无用的，因为所有静态方法调用都是在编译时解析的。所以，它们没有真正的用处。

对于泛型，它们可以使用——无论是否使用默认实现。显然需要重写等等。然而，我的猜测是，这样的用法不是很面向对象(正如其他答案迟钝地指出的那样)，因此被认为不值得付出努力来有效地实现它们。

这个问题已经被问过了

重复我的回答:

在接口中声明静态方法从来没有意义。它们不能通过正常调用MyInterface.staticMethod()来执行。如果您通过指定实现类myimplemtor . staticmethod()来调用它们，那么您必须知道实际的类，因此接口是否包含它是无关紧要的。

更重要的是，静态方法永远不会被重写，如果你试图这样做:

MyInterface var = new MyImplementingClass();
var.staticMethod();

static的规则说必须执行在声明的var类型中定义的方法。因为这是一个接口，所以这是不可能的。

不能执行“result=MyInterface. staticmethod()”的原因是它必须执行MyInterface中定义的方法的版本。但MyInterface中不能定义一个版本，因为它是一个接口。它没有定义上的代码。

虽然你可以说这相当于“因为Java是这样做的”，但实际上，这个决定是其他设计决策的逻辑结果，也有很好的理由。

有几个答案讨论了可覆盖静态方法概念的问题。然而，有时你会遇到一种模式，它似乎正是你想要使用的。

例如，我使用对象关系层，该层有值对象，但也有用于操作值对象的命令。由于各种原因，每个值对象类都必须定义一些静态方法，以便框架找到命令实例。例如，要创建一个Person，你可以这样做:

cmd = createCmd(Person.getCreateCmdId());
Person p = cmd.execute();

通过ID加载Person

cmd = createCmd(Person.getGetCmdId());
cmd.set(ID, id);
Person p = cmd.execute();

这是相当方便的，但它有它的问题;值得注意的是，静态方法的存在不能在接口中强制执行。接口中可覆盖的静态方法正是我们所需要的，只要它能以某种方式工作。

EJBs solve this problem by having a Home interface; each object knows how to find its Home and the Home contains the "static" methods. This way the "static" methods can be overridden as needed, and you don't clutter up the normal (it's called "Remote") interface with methods that don't apply to an instance of your bean. Just make the normal interface specify a "getHome()" method. Return an instance of the Home object (which could be a singleton, I suppose) and the caller can perform operations that affect all Person objects.

要解决这个问题: 错误:缺少方法主体，或声明摘要 static void main(String[] args);

interface I
{
    int x=20;
    void getValue();
    static void main(String[] args){};//Put curly braces 
}
class InterDemo implements I
{
    public void getValue()
    {
    System.out.println(x);
    }
    public static void main(String[] args)
    {
    InterDemo i=new InterDemo();
    i.getValue();   
    }

}

输出: 20.

现在我们可以在接口中使用静态方法