Java – declaring from Interface type instead of Class

by

When there is a choice between referring to an object by their interface or a class, the former should be preferred, but only if an appropriate type exists.

Consider StringimplementsCharSequence as an example. You should not just blindly use CharSequence in preferrence to String for all cases, because that would deny you simple operations like trim(), toUpperCase(), etc.

However, a method that takes a String only to care about its sequence of char values should use CharSequence instead, because that is the appropriate type in this case. This is in fact the case with replace(CharSequence target, CharSequence replacement) in the String class.

Another example is java.util.regex.Pattern and its Matcher matcher(CharSequence) method. This lets a Matcher be created from Pattern for not just String, but also for all other CharSequence there are out there.

A great example in the library of where an interface should’ve been used, but unfortunately wasn’t, can also be found in Matcher: its appendReplacement and appendTail methods accept only StringBuffer. This class has largely been replaced by its faster cousin StringBuilder since 1.5.

A StringBuilder is not a StringBuffer, so we can not use the former with the append… methods in Matcher. However, both of them implementsAppendable (also introduced in 1.5). Ideally Matcher‘s append… method should accept any Appendable, and we would then be able to use StringBuilder, as well as all other Appendable available!

So we can see how when an appropriate type exists referring to objects by their interfaces can be a powerful abstraction, but only if those types exist. If the type does not exist, then you may consider defining one of your own if it makes sense. In this Cat example, you may define interface SelfBathable, for example. Then instead of referring to a Cat, you can accept any SelfBathable object (e.g. a Parakeet)

If it does not make sense to create a new type, then by all means you can refer to it by its class.

See also

  • Effective Java 2nd Edition, Item 52: Refer to objects by their interfaces

    If appropriate interface types exist, then parameters, return values, and fields should all be declared using interface types. If you get into the habit of using interface types, your program will be much more flexible. It is entirely appropriate to refer to an object by a class if no appropriate interface exists.

Related links

More Related Contents:

  1. Attempt to invoke interface method ‘int java.util.List.size()’ on a null object How Solve It? [duplicate]
  2. Why should the interface for a Java class be preferred?
  3. Abstract class in Java
  4. Java – Method name collision in interface implementation
  5. Why is there no multiple inheritance in Java, but implementing multiple interfaces is allowed?
  6. What is an interface in Java?
  7. Explicitly calling a default method in Java
  8. Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?
  9. When to use abstract class or interface? [closed]
  10. How to create interface between Fragment and adapter?
  11. The difference between the Runnable and Callable interfaces in Java
  12. How to implement enum with generics?
  13. Can we create an instance of an interface in Java? [duplicate]
  14. Interface naming in Java [closed]
  15. Java Interfaces Methodology: Should every class implement an interface?
  16. What does it mean to program to an interface?
  17. Inner class within Interface
  18. How to use interface to communicate between two activities
  19. Why does it compile when casting to an unrelated interface? [duplicate]
  20. not implementing all of the methods of interface. is it possible?
  21. Java getting an error for implementing interface method with weaker access
  22. Why are all fields in an interface implicitly static and final?
  23. How to write junit tests for interfaces?
  24. Optional Methods in Java Interface
  25. Implementing two interfaces with two default methods of the same signature in Java 8
  26. Passing function as a parameter in java
  27. Meaning of “Cannot reduce the visibility of the inherited method” with an interface
  28. Where to put @Transactional? In interface specification or implementation? [duplicate]
  29. Why are interfaces preferred to abstract classes?
  30. How to serialize a class with an interface?

Leave a Comment