In Java, is there a performance gain in using inte

Question

The title is hardly understandable, but I'm not sure how to summarize that another way. Any edit to clarify is welcome.

I have been told, and recommended to use interfaces to improve performances, even in a case which doesn't especially call for the regular "interface" role. In this case, the objects are big models (in a MVC meaning), with many methods and fields.

The "good use" that has been recommended to me is to create an interface, with its unique implementation. There won't be any other class implementing this interface, for sure. I have been told that this is better to do so, because it "exposes less" (or something close) to the other classes which will use methods from this class, as these objects are referring to the object from its interface (all public methods from the implementation being reproduced in the interface).

This seems quite strange to me, as it seems like a C++ use to me (with header files). There I see the point, but in Java?

Is there really a point in making an interface for such unique implementation? I would really appreciate some clarifications on the topic, so I could justify not following such kind of behavior, and the hassle it creates from duplicating all declarations.

---

Edit: Thanks everybody for the answers, it was really helpful and instructive (most of them, not only the "accepted" one).

There is clearly no advantage in performance, and I now have a larger scope of the interest that can come from it (depending on the situation), besides the usual OO role of the interface.

Answer 1

This question targeted C#, but I think it applies as well. The highest voted answer says that defining an interface for every class is just code noise.

Answer 2

In fact, using interfaces instead of classes allows you three things :

1. Dstinguish the contract from its implementation : the contract is the interface (it's what you declare you'll do) and the class is obviously the implemenation
2. Provide easily altrnative implementation. Typical examples of this imply replacing a storage mechanism by another without modifying user code (like repalcing MySQL by, say, Project Voldemort)
3. As a benefit of 2 (and this time easily extendable to model elements), interfaces allow you to do kind of white box testing : by using a mocking framework (JMock, EasyMock, ...), you'll repalce your implementation of the interface, which behaviour may be suspicious, by a so-called "mock" returning exactly what you expect for your test. This will allow your test to not only check one component, but also ensure the error come from that component, and not from its inner contractors (the interface you give him).

Answer 3

Interfaces are incredibly overused in Java partly because of the language design and partly because people think making lots of interfaces is good design.

Abstract classes would be superior to interfaces if Java allowed multiple inheritance. Scala a new programming language for the JVM has a concept of Traits which are essentially abstract classes with MI capability.

The advantage to an abstract class is that you can add behavior to the abstract class with out breaking existing classes that extend it. Thus an abstract class is also better as an extension mechanism (plugin) then interfaces.

Unfortunately JMock and its brethren encourage lots of interfaces for BDD testing but this is not necessarily true because there are at least a couple of libraries to mock concrete objects.

Answer 4

Here's 2 links that explain why you'd want to do this:

http://www.artima.com/lejava/articles/designprinciples.html http://pragmaticjava.blogspot.com/2008/08/program-to-interface-not-implementation.html

It has nothing to do execution performance(more to do with programmer(you) performance), in that you're decopling users of a class from its implemenation - among other things for easing testability and maintainability.

There won't be any other class implementing this interface, for sure.

Maybe not this year, but next year there might.

Answer 5

Yet another way to misuse interfaces?

There are no obvious performance gain using interfaces. Conversely, it may have a negative performance impact due to RTTI (Based on your compiler's features)

Answer 6

There is a relatively common development dogma that there should be an interface for pretty much everything. As far as I can tell, this is based either on a cargo-cult mentality in regard to "program to an interface, not an implementation" (which most definitely does not require you to litter you code with interfaces all over), or on doing test-driven-development with older mocking frameworks that couldn't mock concrete classes.

Disregard such nonsense.