一个接口永远不能被静态地解引用，例如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是这样做的”，但实际上，这个决定是其他设计决策的逻辑结果，也有很好的理由。

因为静态方法不能在子类中重写，因此它们不能是抽象的。事实上，接口中的所有方法都是抽象的。

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

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

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

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

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