0

Effective java encourages use to interfaces rather than abstract / concrete classes. Question is if there is an interface heirachy, which interface type should be chosen and why ?

For example, an ArrayList implements List which implements Collection which implements a Iterable. So when do we pass a list vs collection vs iterable ?

Obvious answer is that each subclasses keep adding more functions. So should we keep climb up the hierarchy until the required functionality is matched ? I mean if in an imaginary application only iterator() is needed then use Iterable else use List ?

Alex
  • 21,273
  • 10
  • 61
  • 73
JavaDeveloper
  • 5,320
  • 16
  • 79
  • 132
  • The preference will come down to the needs if the API – MadProgrammer Oct 20 '13 at 00:20
  • but if more than two satisfy then do we take the one highest in hierarchy ? – JavaDeveloper Oct 20 '13 at 00:21
  • 1
    I would take the one which most clearly explains what you are trying to do. This can be the highest, but sometimes this is too generic for your purposes. For example often `Set` can be replaced with `Collection` as they have the same methods, but only `Set` says you expect the elements to be unique. – Peter Lawrey Oct 20 '13 at 00:35
  • possible duplicate of [When should I use Iterable vs. Collection in Java?](http://stackoverflow.com/questions/1159797/when-should-i-use-iterable-vs-collection-in-java) – Alvin Wong Oct 20 '13 at 04:51

2 Answers2

3

Always use the most abstracted interface that fulfills your needs.

In the example of Iterable, Collection, List, if you only need to iterate then only pass around an Iterable. If you only need methods provided by Collection then only pass around a collection.

The reason for this is so that you can easily replace later.

For example, if you have a function that only needs an Iterable but takes a List as a function parameter, then later if you decide that it makes more sense to store your data as a HashSet you have to change a lot of code to make it work. However, since HashSet is Iterable, if you had just passed an Iterable to your function originally you would have had to change much less code.

It also makes testing easier in some cases. For example, Imagine you have some interface Foo that extends interface Bar. If you have a function that takes a Foo parameter then you have to mock everything that Bar expects and you have to mock everything that Foo adds onto that. If your function only expected a Bar parameter then you only have to mock Bar.

Micah Zoltu
  • 6,764
  • 5
  • 44
  • 72
0

It is clear, from his comments, that OP wanted all along to go for "most abstract", and normally I'd agree.

But, in my practical experience, size() is really really useful. (joke omitted). And often becomes more useful as your code evolves. So, to plan ahead, my suggestion, in this specific example, is to go with Collection over Iterable.

user949300
  • 15,364
  • 7
  • 35
  • 66