blocks|key|1522129|text|使用接口而不是具体类型是良好的封装和松散耦合代码的关键。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522130|在编写您自己的API时，遵循这种做法甚至是一个好主意。如果您这样做了，您稍后会发现向代码中添加单元测试(使用模拟技术)以及在将来需要时更改底层实现会更容易。|1522131|这是一个关于这个主题的good+article。|offset|length|1522132|希望它能帮上忙！|1522133|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javaworld.com/javaworld/jw-08-2003/jw-0801-toolbox.html^0|0|0|B|C|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$F|U|G|V|1|W]]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Using interfaces over concrete types is the key for good encapsulation and for loose coupling your code.

It's even a good idea to follow this practice when writing your own APIs. If you do, you'll find later that it's easier to add unit tests to your code (using Mocking techniques), and to change the underlying implementation if needed in the future.

Here's a <a href="http://www.javaworld.com/javaworld/jw-08-2003/jw-0801-toolbox.html" rel="noreferrer">good article</a> on the subject.

Hope it helps!

blocks|key|1522076|text|这是首选的，因为您可以将代码从列表的实现中解耦。使用该接口，您可以轻松地将实现(本例中为ArrayList+)更改为另一个List实现，而无需更改任何剩余代码，只要它只使用list中定义的方法即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522077|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|$]]

This is preferred because you decouple your code from the implementation of the list. Using the interface lets you easily change the implementation, ArrayList in this case, to another list implementation without changing any of the rest of the code as long as it only uses methods defined in List.

blocks|key|1522328|text|总的来说，我同意将接口与实现分离是一件好事，这将使您的代码更易于维护。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522329|但是，您必须考虑一些例外情况。通过接口访问对象会增加额外的间接层，这会使代码变慢。|1522330|出于兴趣，我运行了一个实验，生成100亿次对100万个长度的ArrayList的顺序访问。在我的2.4+the上，通过列表接口访问ArrayList平均需要2.10秒，当声明它为ArrayList类型时，平均需要1.67秒。|1522331|如果您正在处理大型列表，深入内部循环或频繁调用函数，则需要考虑这一点。|1522332|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|$]]

In general I agree that decoupling interface from implementation is a good thing and will make your code easier to maintain.

There are, however, exceptions that you must consider. Accessing objects through interfaces adds an additional layer of indirection that will make your code slower. 

For interest I ran an experiment that generated ten billion sequential accesses to a 1 million length ArrayList. On my 2.4Ghz MacBook, accessing the ArrayList through a List interface took 2.10 seconds on average, when declaring it of type ArrayList it took on average 1.67 seconds. 

If you are working with large lists, deep inside an inner loop or frequently called function, then this is something to consider.

blocks|key|1522183|text|ArrayList和LinkedList是List的两个实现，List是项的有序集合。从逻辑上讲，使用ArrayList或LinkedList都无关紧要，因此您不应该将类型限制为该类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522184|这与Collection和List不同，它们是不同的东西(List意味着排序，Collection不意味着排序)。|1522185|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|$]]

ArrayList and LinkedList are two implementations of a List, which is an ordered collection of items. Logic-wise it doesn't matter if you use an ArrayList or a LinkedList, so you shouldn't constrain the type to be that.

This contrasts with say, Collection and List, which are different things (List implies sorting, Collection does not).

blocks|key|1737277|text|您的类/接口的属性应该通过接口公开，因为它为您的类提供了一个行为契约来使用，而不管实现是什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737278|然而..。|1737279|在局部变量声明中，这样做没有什么意义：|1737280|public+void+someMethod()+{
List+theList+=+new+ArrayList();
//do+stuff+with+the+list
}|code-block|syntax|javascript|1737281|如果它是一个局部变量，只需使用类型。它仍然可以隐式地向上转换到其相应的接口，并且您的方法应该希望接受接口类型作为其参数，但是对于局部变量，使用实现类型作为容器是完全有意义的，以防您确实需要特定于实现的功能。|1737282|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Properties of your classes/interfaces should be exposed through interfaces because it gives your classes a contract of behavior to use, regardless of the implementation.

However...

In local variable declarations, it makes little sense to do this:

<pre><code>public void someMethod() {
List theList = new ArrayList();
//do stuff with the list
}
</code></pre>

If its a local variable, just use the type. It is still implicitly upcastable to its appropriate interface, and your methods should hopefully accept the interface types for its arguments, but for local variables, it makes total sense to use the implementation type as a container, just in case you do need the implementation-specific functionality.

blocks|key|1737441|text|即使对于局部变量，在具体类上使用接口也会有所帮助。您可能会调用接口外部的方法，然后在必要时很难更改List的实现。此外，最好在声明中使用最不具体的类或接口。如果元素顺序无关紧要，则使用集合而不是列表。这为您的代码提供了最大的灵活性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737442|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|$]]

Even for local variables, using the interface over the concrete class helps. You may end up calling a method that is outside the interface and then it is difficult to change the implementation of the List if necessary.
Also, it is best to use the least specific class or interface in a declaration. If element order does not matter, use a Collection instead of a List. That gives your code the maximum flexibility.

blocks|key|1737506|text|接口向最终用户公开。一个类可以实现多个接口。暴露于特定接口用户可以访问在该特定接口中定义的某些特定行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737507|一个接口也有多个实现。基于场景系统将使用不同的场景(接口的实现)。|1737508|如果你需要更多的解释，请告诉我。|1737509|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|$]]

Interface is exposed to the end user. One class can implement multiple interface. User who have expose to specific interface have access to some specific behavior which are defined in that particular interface.

One interface also have multiple implementation. Based on the scenario system will work with different scenario (Implementation of the interface).

let me know if you need more explanation.

blocks|key|1522551|text|在调试器视图中，接口通常比具体类具有更好的表示形式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522552|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 interface often has better representation in the debugger view than the concrete class.

<a href="https://pmd.github.io/" rel="noreferrer">PMD</a> would report a violation for:

<pre><code>ArrayList&lt;Object&gt; list = new ArrayList&lt;Object&gt;();
</code></pre>

The violation was "Avoid using implementation types like 'ArrayList'; use the interface instead".

The following line would correct the violation:

<pre><code>List&lt;Object&gt; list = new ArrayList&lt;Object&gt;();
</code></pre>

Why should the latter with <code>List</code> be used instead of <code>ArrayList</code>?

Why should the interface for a Java class be preferred?

单元测试

调试器

容器

将针对以下情况报告违规：ArrayList<Object> list = new ArrayList<Object>();违规是“避免使用像‘ArrayList’这样的实现类型；使用接口来代替”。下面这一行可以纠正违规行为：List<Object> list = new ArrayList<Object>();为什么应该使用带有List的后者而不是ArrayList

问为什么应该首选Java类的接口？
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么应该首选Java类的接口？EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么应该首选Java类的接口？
EN