blocks|key|1779982|text|静态方法不是实例方法。没有实例上下文，因此从接口实现它意义不大。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1779983|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Static methods are not instance methods. There's no instance context, therefore to implement it from the interface makes little sense.

blocks|key|1780029|text|我将用一个例子来回答你的问题。假设我们有一个具有静态方法add的Math类。您可以像这样调用此方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780030|Math.add(2,+3);|code-block|syntax|javascript|1780031|如果Math是一个接口而不是一个类，它就不能有任何已定义的函数。因此，像Math.add(2，3)这样的语句没有任何意义。|1780032|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'll answer your question with an example. Suppose we had a Math class with a static method add. You would call this method like so:

<pre><code>Math.add(2, 3);
</code></pre>

If Math were an interface instead of a class, it could not have any defined functions. As such, saying something like Math.add(2, 3) makes no sense.

blocks|key|1564990|text|不能在接口中使用静态方法的原因在于Java解析静态引用的方式。在尝试执行静态方法时，Java不会费心查找类的实例。这是因为静态方法不依赖于实例，因此可以直接从类文件执行。假设接口中的所有方法都是抽象的，VM将必须查找接口的特定实现，以便找到静态方法背后的代码，以便可以执行它。这就与静态方法解析的工作方式相矛盾，并会给语言带来不一致。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1564991|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The reason why you can't have a static method in an interface lies in the way Java resolves static references. Java will not bother looking for an instance of a class when attempting to execute a static method. This is because static methods are not instance dependent and hence can be executed straight from the class file. Given that all methods in an interface are abstract, the VM would have to look for a particular implementation of the interface in order to find the code behind the static method so that it could be executed. This then contradicts how static method resolution works and would introduce an inconsistency into the language.

blocks|key|1780149|text|接口用于多态性，它适用于对象，而不是类型。因此(如前所述)，拥有一个静态接口成员是没有意义的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780150|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

An interface is used for polymorphism, which applies to Objects, not types. Therefore (as already noted) it makes no sense to have an static interface member.

blocks|key|1565111|text|也许代码示例会有所帮助，我将使用C#，但您应该能够跟随。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1565112|假设我们有一个名为IPayable的接口|1565113|public+interface+IPayable
{
++++public+Pay(double+amount);
}|code-block|syntax|javascript|1565114|现在，我们有两个实现此接口的具体类：|1565115|public+class+BusinessAccount+:+IPayable
{
++++public+void+Pay(double+amount)
++++{
++++++++//Logic
++++}
}

public+class+CustomerAccount+:+IPayable
{
++++public+void+Pay(double+amount)
++++{
++++++++//Logic
++++}
}|1565116|现在，让我们假设我们有一个不同帐户的集合，为此，我们将使用IPayable类型的泛型列表|1565117|List<IPayable>+accountsToPay+=+new+List<IPayable>();
accountsToPay.add(new+CustomerAccount());
accountsToPay.add(new+BusinessAccount());|1565118|现在，我们要向所有这些帐户支付50美元：|1565119|foreach+(IPayable+account+in+accountsToPay)
{
++++account.Pay(50.00);
}|1565120|现在你可以看到接口是多么的有用了。|1565121|它们仅用于实例化的对象。不是在静态类上。|1565122|如果你把pay设为静态的，当在accountsToPay中遍历IPayable的时候，就无法确定它是应该在BusinessAcount还是CustomerAccount上调用pay。|1565123|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Perhaps a code example would help, I'm going to use C#, but you should be able to follow along.

Lets pretend we have an interface called IPayable

<pre><code>public interface IPayable
{
 public Pay(double amount);
}
</code></pre>

Now, we have two concrete classes that implement this interface:

<pre><code>public class BusinessAccount : IPayable
{
 public void Pay(double amount)
 {
 //Logic
 }
}

public class CustomerAccount : IPayable
{
 public void Pay(double amount)
 {
 //Logic
 }
}
</code></pre>

Now, lets pretend we have a collection of various accounts, to do this we will use a generic list of the type IPayable

<pre><code>List&lt;IPayable&gt; accountsToPay = new List&lt;IPayable&gt;();
accountsToPay.add(new CustomerAccount());
accountsToPay.add(new BusinessAccount());
</code></pre>

Now, we want to pay $50.00 to all those accounts:

<pre><code>foreach (IPayable account in accountsToPay)
{
 account.Pay(50.00);
}
</code></pre>

So now you see how interfaces are incredibly useful. 

They are used on instantiated objects only. Not on static classes. 

If you had made pay static, when looping through the IPayable's in accountsToPay there would be no way to figure out if it should call pay on BusinessAcount or CustomerAccount.

blocks|key|1565230|text|原因在于设计原则，即java不允许多重继承。多重继承的问题可以通过下面的示例来说明：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1565231|public+class+A+{
+++public+method+x()+{...}
}
public+class+B+{
+++public+method+x()+{...}
}
public+class+C+extends+A,+B+{+...+}|code-block|syntax|javascript|1565232|现在，如果调用C.x()会发生什么？将执行A.x()或B.x()？每一种具有多重继承的语言都必须解决这个问题。|1565233|在Java中，接口允许某种受限制的多重继承。为了避免上面的问题，他们不允许有方法。如果我们看一下接口和静态方法的相同问题：|1565234|public+interface+A+{
+++public+static+method+x()+{...}
}
public+interface+B+{
+++public+static+method+x()+{...}
}
public+class+C+implements+A,+B+{+...+}|1565235|这里也有同样的问题，如果调用C.x()会发生什么？|1565236|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The reason lies in the design-principle, that java does not allow multiple inheritance. The problem with multiple inheritance can be illustrated by the following example:

<pre><code>public class A {
 public method x() {...}
}
public class B {
 public method x() {...}
}
public class C extends A, B { ... }
</code></pre>

Now what happens if you call C.x()? Will be A.x() or B.x() executed? Every language with multiple inheritance has to solve this problem.

Interfaces allow in Java some sort of restricted multiple inheritance. To avoid the problem above, they are not allowed to have methods. If we look at the same problem with interfaces and static methods:

<pre><code>public interface A {
 public static method x() {...}
}
public interface B {
 public static method x() {...}
}
public class C implements A, B { ... }
</code></pre>

Same problem here, what happen if you call C.x()?

blocks|key|1565298|text|你的问题有一个非常好和简洁的答案，here。(我觉得这是一种非常直接的解释方式，所以我想从这里链接它。)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1565299|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/370962/why-cant-static-methods-be-abstract-in-java/370967#370967^0|H|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

There's a very nice and concise answer to your question <a href="https://stackoverflow.com/questions/370962/why-cant-static-methods-be-abstract-in-java/370967#370967">here</a>. (It struck me as such a nicely straightforward way of explaining it that I want to link it from here.)

blocks|key|1780389|text|接口中的静态方法似乎在Java+8中得到了支持，我的解决方案就是在内部类中定义它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1780390|interface+Foo+{
++++//+...
++++class+fn+{
++++++++public+static+void+func1(...)+{
++++++++++++//+...
++++++++}
++++}
}|code-block|syntax|javascript|1780391|在注释中也可以使用相同的技术：|1780392|public+@interface+Foo+{
++++String+value();

++++class+fn+{
++++++++public+static+String+getValue(Object+obj)+{
++++++++++++Foo+foo+=+obj.getClass().getAnnotation(Foo.class);
++++++++++++return+foo+==+null+?+null+:+foo.value();
++++++++}
++++}
}|1780393|内部类应该始终以Interface.fn...的形式访问，而不是以Class.fn...的形式访问，这样就可以消除多义性问题。|style|CODE|1780394|entityMap|0|LINK|mutability|MUTABLE|url|http://www.techempower.com/blog/2013/03/26/everything-about-java-8/^0|B|6|0|0|0|0|0|8|F|X|B|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@$A|16|B|17|O|P]|$A|18|B|19|O|P]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

It seems the static method in the interface might be supported in <a href="http://www.techempower.com/blog/2013/03/26/everything-about-java-8/" rel="nofollow">Java 8</a>, well, my solution is just define them in the inner class.

<pre><code>interface Foo {
 // ...
 class fn {
 public static void func1(...) {
 // ...
 }
 }
}
</code></pre>

The same technique can also be used in annotations:

<pre><code>public @interface Foo {
 String value();

 class fn {
 public static String getValue(Object obj) {
 Foo foo = obj.getClass().getAnnotation(Foo.class);
 return foo == null ? null : foo.value();
 }
 }
}
</code></pre>

The inner class should always be accessed in the form of <code>Interface.fn...</code> instead of <code>Class.fn...</code>, then, you can get rid of ambiguous problem.

blocks|key|1780444|text|修饰符组合非法:静态和抽象|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780445|如果类的成员被声明为静态的，则可以将其与其仅限于该类的类名一起使用，而无需创建对象。|1780446|如果某个类的成员声明为抽象，则需要将该类声明为抽象，并且需要在其继承类(Sub-+class+)中提供抽象成员的实现。|1780447|您需要在子类中为类的抽象成员提供一个实现，在子类中，您将更改静态方法的行为，也声明为抽象，这是不正确的|1780448|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Illegal combination of modifiers : static and abstract

If a member of a class is declared as static, it can be used with its class name which is confined to that class, without creating an object.

If a member of a class is declared as abstract, you need to declare the class as abstract and you need to provide the implementation of the abstract member in its inherited class (Sub-Class).

You need to provide an implementation to the abstract member of a class in sub-class where you are going to change the behaviour of static method, also declared as abstract which is a confined to the base class, which is not correct

blocks|key|1565455|text|因为静态方法不能被继承。所以把它放在界面上是没有用的。接口基本上是一个所有订阅者都必须遵守的契约。在接口中放置一个静态方法将强制订阅者实现它。这与静态方法不能被继承的事实相矛盾。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1565456|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Since static methods can not be inherited . So no use placing it in the interface. Interface is basically a contract which all its subscribers have to follow . Placing a static method in interface will force the subscribers to implement it . which now becomes contradictory to the fact that static methods can not be inherited .

blocks|key|1780530|text|现在Java8允许我们在接口中定义甚至是静态方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780531|interface+X+{
++++static+void+foo()+{
+++++++System.out.println("foo");
++++}
}

class+Y+implements+X+{
++++//...
}

public+class+Z+{
+++public+static+void+main(String[]+args)+{
++++++X.foo();
++++++//+Y.foo();+//+won't+compile+because+foo()+is+a+Static+Method+of+X+and+not+Y
+++}
}|code-block|syntax|javascript|1780532|注意:如果我们不显式地使用关键字default/static将接口中的方法设为默认方法，那么默认情况下接口中的方法仍然是公共抽象的。|1780533|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Now Java8 allows us to define even Static Methods in Interface.

<pre><code>interface X {
 static void foo() {
 System.out.println("foo");
 }
}

class Y implements X {
 //...
}

public class Z {
 public static void main(String[] args) {
 X.foo();
 // Y.foo(); // won't compile because foo() is a Static Method of X and not Y
 }
}
</code></pre>

Note: Methods in Interface are still public abstract by default if we don't explicitly use the keywords default/static to make them Default methods and Static methods resp.

blocks|key|1780561|text|Java+8改变了世界，你可以在接口中使用静态方法，但它迫使你提供实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780562|public+interface+StaticMethodInterface+{
public+static+int+testStaticMethod()+{
++++return+0;
}

/**
+*+Illegal+combination+of+modifiers+for+the+interface+method
+*+testStaticMethod;+only+one+of+abstract,+default,+or+static+permitted
+*+
+*+@param+i
+*+@return
+*/
//+public+static+abstract+int+testStaticMethod(float+i);

default+int+testNonStaticMethod()+{
++++return+1;
}

/**
+*+Without+implementation.
+*+
+*+@param+i
+*+@return
+*/
int+testNonStaticMethod(float+i);|code-block|syntax|javascript|1780563|}|1780564|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Java 8 Had changed the world you can have static methods in interface but it forces you to provide implementation for that.

<pre><code>public interface StaticMethodInterface {
public static int testStaticMethod() {
 return 0;
}

/**
 * Illegal combination of modifiers for the interface method
 * testStaticMethod; only one of abstract, default, or static permitted
 * 
 * @param i
 * @return
 */
// public static abstract int testStaticMethod(float i);

default int testNonStaticMethod() {
 return 1;
}

/**
 * Without implementation.
 * 
 * @param i
 * @return
 */
int testNonStaticMethod(float i);
</code></pre>

}

The topic says the most of it - what is the reason for the fact that static methods can't be declared in an interface?

<pre><code>public interface ITest {
 public static String test();
}
</code></pre>

The code above gives me the following error (in Eclipse, at least): "Illegal modifier for the interface method ITest.test(); only public &amp; abstract are permitted".

Why can't I declare static methods in an interface?

Eclipse

Java

这个主题最能说明问题--静态方法不能在接口中声明的原因是什么？public interface ITest {    public static String test();}上面的代码给了我以下错误(至少在Eclipse中是这样的)：“接口方法ITest.test()的非法修饰符；只允许公共和抽象”。

问为什么我不能在接口中声明静态方法？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能在接口中声明静态方法？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我不能在接口中声明静态方法？
EN