Comments on: Should we discard Interfaces?

By: Daily del.icio.us for May 18th through May 20th — Vinny Carpenter’s blog

Wed, 21 May 2008 02:01:58 +0000

[...] Should we discard Interfaces? | Learning by Experience – Is a class that only has interfaces as dependencies easier to test then classes that have implementations as dependencies? Most of us are eager to say yes, but in fact, frameworks like EasyMock enable us to mock (non final) classes. [...]

By: Mark Brackett

Mark Brackett — Mon, 19 May 2008 23:54:00 +0000

The fact that EasyMock, or other mocking frameworks, enable you to bypass the interface when mocking is immaterial – after all, I *could* test private functions as well. Or, use post-compilers to inject my own code.
The point of unit testing isn’t only the testing – it’s the seams that (if done properly) it forces you to put in to enable that testing. Interfaces are one such seam.

By: alvin

alvin — Mon, 19 May 2008 15:27:30 +0000

I am of the school of thought that you touch upon here – which is really questioning the use of interfaces.

Interfaces I think have a place, especially if the software you are working on will be packaged and used by others. There are of course other instances when you interfaces are indeed called for (e.g. you will have more than one implementation, want to simulate multiple inheritance or in specific design patterns such as Observer pattern).

But when you are working on something that is specifically for yourself I am not sure it is really needed.

When I ask some people why should I use an interface they allude to the same points you mentioned.
- Ease of testing – solved by a number of test frameworks
- More than one implementation – in my programming experience the times when you will have a single implementation vastly outnumber the multiple.

Interested to hear peoples thoughts.

By: Christian

Christian — Sun, 18 May 2008 15:43:20 +0000

I think the best examples of interface use are design patterns such Command, Strategy, State or even the Proxy pattern. They are all based on interfaces for increased flexibility and reuse.
Objects can also implement many interfaces, but only extend one class (inheritance could be considered as a compile time dependency). An example of object reuse: you can divide the public methods of an object over multiple interfaces based on its use from the clients, to make it usable from different viewpoints. The same object could be used by different clients, each time with another interface. That same object would be reusable in different circumstances (but be careful for anti-patterns).

By: David

David — Sat, 17 May 2008 21:49:06 +0000

Andries,

Although interfaces are useful, they should be used with care.

I personally believe interfaces offer a way to safely connect different modules and/or packages of a project. Within a package, interfaces are rarely useful, with the exception of defining a common ‘interface’ of different classes.

Anyway, with the IDEs we use nowadays it is dead simple to extract an interface from a given class whenever we need it.