blocks|key|1439822|text|字段必须是静态的，因为它们不能是抽象的(就像方法一样)。因为它们不能是抽象的，实现者将不能在逻辑上提供字段的不同实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439823|字段必须是最终的，我认为，因为字段可以被许多不同的实现者访问，允许它们是可改变的可能是有问题的(因为同步)。也是为了避免它被重新实现(隐藏)。|1439824|这只是我的想法。|1439825|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The fields must be static because they can't be abstract (like methods can). Because they can't be abstract, the implementers will not be able to logically provide the different implementation of the fields.

The fields must be final, I think, because the fields may be accessed by many different implementers allows they to be changeable might be problematic (as synchronization). Also to avoid it to be re-implemented (hidden).

Just my thought.

blocks|key|1225160|text|接口旨在指定交互契约，而不是实现细节。开发人员应该能够通过查看接口来使用实现，而不必查看实现它的类内部。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225161|接口不允许创建其实例，因为您不能指定构造函数。所以它不能有实例状态，尽管接口字段可以定义常量，这些常量是隐式静态的和最终的。|1225162|您不能在接口中指定方法体或初始值设定项块，但从Java+8开始，您可以使用bodies指定默认方法。此功能旨在允许将新方法添加到现有接口，而不必更新所有实现。但是，如果不先创建一个实现接口的实例，您仍然不能执行这样的方法。|1225163|旁白:请注意，您可以使用匿名内部类实现一个接口：|1225164|interface+Foo+{
++++String+bar();
}

class+FooBar+{
++++Foo+anonymous+=+new+Foo()+{
+++++++++public+String+bar()+{
+++++++++++++return+"The+Laundromat+Café";
++++};
}|code-block|syntax|javascript|1225165|您必须提供接口的完整实现，以便匿名内部类进行编译。|1225166|new+Foo()正在使用其默认构造函数初始化匿名内部类。|offset|length|style|CODE|1225167|entityMap^0|0|0|0|0|0|0|0|9|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

An interface is intended to specify an interaction contract, not implementation details. A developer should be able to use an implementation just by looking at the interface, and not have to look inside the class which implements it.
An interface does not allow you to create an instance of it, because you cannot specify constructors. So it cannot have instance state, although interface fields can define constants, which are implicitly static and final.
You cannot specify method bodies or initializer blocks in an interface, although since Java 8 you can specify default methods with bodies. This feature is intended to allow new methods to be added to existing interfaces without having to update all the implementations. But you still cannot execute such a method, without first creating an instance implementing the interface.
Aside: Note that you can implement an interface with an anonymous inner class:
<pre><code>interface Foo {
 String bar();
}

class FooBar {
 Foo anonymous = new Foo() {
 public String bar() {
 return &quot;The Laundromat Café&quot;;
 };
}
</code></pre>
You have to provide the full implementation of the interface for the anonymous inner class to compile.
<code>new Foo()</code> is initializing the anonymous inner class with its default constructor.

blocks|key|1225227|text|我认为要求字段是final是不适当的限制，这是Java语言设计者的错误。有时，例如树处理，当您需要在实现中设置常量时，需要在接口类型的对象上执行操作。在实现类上选择代码路径是一项繁琐的工作。我使用的变通方法是定义一个接口函数，并通过返回一个文本来实现它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225228|public+interface+iMine+{
++++String+__ImplementationConstant();
++++...
}

public+class+AClass+implements+iMine+{
++++public+String+__ImplementationConstant(){
++++++++return+"AClass+value+for+the+Implementation+Constant";
++++}
++++...
}

public+class+BClass+implements+iMine+{
++++public+String+__ImplementationConstant(){
++++++++return+"BClass+value+for+the+Implementation+Constant";
++++}
++++...
}|code-block|syntax|javascript|1225229|但是，使用以下语法会更简单、更清晰，也不容易出现异常实现：|1225230|public+interface+iMine+{
++++String+__ImplementationConstant;
++++...
}

public+class+AClass+implements+iMine+{
++++public+static+String+__ImplementationConstant+=
++++++++"AClass+value+for+the+Implementation+Constant";
++++...
}

public+class+BClass+implements+iMine+{
++++public+static+String+__ImplementationConstant+=
++++++++"BClass+value+for+the+Implementation+Constant";
++++...
}|1225231|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I consider the requirement that the fields be final as unduly restrictive and a mistake by the Java language designers. There are times, e.g. tree handling, when you need to set constants in the implementation which are required to perform operations on an object of the interface type. Selecting a code path on the implementing class is a kludge. The workaround which I use is to define an interface function and implement it by returning a literal:

<pre><code>public interface iMine {
 String __ImplementationConstant();
 ...
}

public class AClass implements iMine {
 public String __ImplementationConstant(){
 return "AClass value for the Implementation Constant";
 }
 ...
}

public class BClass implements iMine {
 public String __ImplementationConstant(){
 return "BClass value for the Implementation Constant";
 }
 ...
}
</code></pre>

However, it would be simpler, clearer and less prone to aberrant implementation to use this syntax:

<pre><code>public interface iMine {
 String __ImplementationConstant;
 ...
}

public class AClass implements iMine {
 public static String __ImplementationConstant =
 "AClass value for the Implementation Constant";
 ...
}

public class BClass implements iMine {
 public static String __ImplementationConstant =
 "BClass value for the Implementation Constant";
 ...
}
</code></pre>

blocks|key|1225313|text|规格，合同...用于字段访问的机器指令使用对象地址加上字段偏移量。由于类可以实现许多接口，因此无法使非最终接口字段在扩展此接口的所有类中具有相同的偏移量。因此，必须实现不同的字段访问机制:两次内存访问(获取字段偏移量，获取字段值)，而不是一次加维护一种虚拟字段表(类似于虚拟方法表)。我猜他们只是不想让jvm的功能复杂化，这些功能可以通过现有的东西(方法)很容易地模拟出来。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225314|在scala中，我们可以在接口中包含字段，尽管在内部它们是像我上面解释的那样实现的(作为方法)。|1225315|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Specification, contracts... The machine instruction for field access uses object address plus field offset. Since classes can implement many interfaces, there is no way to make non-final interface field to have the same offset in all classes that extend this interface. Therefore different mechanism for field access must be implemented: two memory accesses (get field offset, get field value) instead of one plus maintaining kind of virtual field table (analog of virtual method table). Guess they just didn't want to complicate jvm for functionality that can be easily simulated via existing stuff (methods).

In scala we can have fields in interfaces, though internally they are implemented as I explained above (as methods).

I am just trying to understand why all fields defined in an Interface are implicitly <code>static</code> and <code>final</code>. The idea of keeping fields <code>static</code> makes sense to me as you can't have objects of an interface but why they are <code>final</code> (implicitly)?

Any one knows why Java designers went with making the fields in an interface <code>static</code> and <code>final</code>?

Why are all fields in an interface implicitly static and final?

Java

我只是试图理解为什么接口中定义的所有字段都隐式地是static和final。保持字段static的想法对我来说很有意义，因为你不能拥有接口的对象，但是为什么它们是final (隐式地)呢？任何人都知道为什么Java设计人员要在接口static和final中创建字段

问为什么一个接口中的所有字段都隐式地是静态的和最终的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么一个接口中的所有字段都隐式地是静态的和最终的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么一个接口中的所有字段都隐式地是静态的和最终的？
EN