Should you always Code To Interfaces In Java [closed]

by

In general I agree with the other answers: use an interface when you know or anticipate change and/or different implementation, or go for testability.

But it’s not always easy to know in advance what may change in the future, especially if you are not so experienced. I think the solution for that problem is refactoring: keep it simple (= no interface) as long as it is not needed. When the need arises simply do an “Introduce/Extract interface” refactoring (supported by almost all decent IDEs).

When you do it extract only those methods that are actually needed by the callers. Don’t be afraid to extract more then one separate interfaces (if not all of the extracted methods are really coherent).

One driver of the refactoring might be the testing: if you can’t easily test something with classes only consider introducing one/some interface(s). This will also allow you to use mocking which may greatly simplify testing in many cases.

Edit: based on Tarski’s comment I’ve realized one more important scenario/adjustment to the previous statements:
If you provide an external API (for other [sub]projects, or really release it “to the wild”) then using interfaces in the API (except for simple value classes) is almost always a good idea.
It will allow you to change the impl if you like without disturbing the client code. You will have a problem only if you also have to change the interface. Not breaking compatibility will be very tricky (if not impossible).

More Related Contents:

  1. Abstract class in Java
  2. Why is there no multiple inheritance in Java, but implementing multiple interfaces is allowed?
  3. Is there more to an interface than having the correct methods
  4. What is an interface in Java?
  5. Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?
  6. How should I have explained the difference between an Interface and an Abstract class?
  7. Should we @Override an interface’s method implementation?
  8. Can we create an object of an interface?
  9. Inner class within Interface
  10. How one interface can be used for different background android tasks?
  11. Do/can abstract classes replace interfaces? [duplicate]
  12. When do I have to use interfaces instead of abstract classes? [duplicate]
  13. interface as a method parameter in Java
  14. Why are interfaces preferred to abstract classes?
  15. How much interfaces a class file can implement [closed]
  16. The purpose of interfaces continued
  17. Polymorphism vs Overriding vs Overloading
  18. Why should the interface for a Java class be preferred?
  19. How to create interface between Fragment and adapter?
  20. The difference between the Runnable and Callable interfaces in Java
  21. What is the point of setters and getters in java? [duplicate]
  22. Access private field of another object in same class
  23. Why can’t I declare static methods in an interface?
  24. What is the difference between identity and equality in OOP?
  25. NotSerializableException on anonymous class
  26. Why java.lang.Object is not abstract? [duplicate]
  27. Should methods that throw RuntimeException indicate it in method signature?
  28. Anonymous vs named inner classes? – best practices?
  29. How to serialize a class with an interface?
  30. Methods With Same Name as Constructor – Why?

Leave a Comment