When should one use interfaces?

by

In languages such as Java and C# interfaces provide a means for a class to be have in a polymorphic manner. That is to say a class can satisfy more than one contract – it can behave as multiple different types, a class of one type can be substituted for another. In other languages this can also be provided by multiple inheritance, but there are various disadvantages to this approach. However, having a class behave as more than one type is not the most common motivation for using interfaces.

By programming to interfaces instead of classes you can also decouple your program from specific implementations. This makes it much easier to substitute one class implementation for another. This is particularly useful when writing unit tests where you may wish to swap some heavyweight class implementation with a lightweight mock object. If your program only expects an interface type, and both the heavyweight object and mock object implement said interface, then they are very easy to substitute.

Also, consider a simple Java example where I say have a program that displays pages of data on the screen. Initially I want it to get the data from a database or XML files. If I write my program so that it uses interfaces I can define an interface like so:

public interface PageDatasource {
    public List<Page> getPages();
}

And use it like so:

PageDatasource datasource = // insert concrete PageDatasource implementation here
List<Pages> pages = datasource.getPages();
display(pages);

I can then write separate database and XML implementations that adhere to this interface:

public class DatabasePageDatasource implements PageDatasource {
    public List<Page> getPages() {
        // Database specific code
    }
}

public class XmlPageDatasource implements PageDatasource {
    public List<Page> getPages() {
        // XML specific code
    }
}

Because I used an interface I can now use either implementation – Database or XML – interchangeably without having to change the parts of my program that ask for the page data. The XML and Database implementations likely do completely different things but all my program cares about is that the object supplying the page data implements the PageDatasource interface.

More Related Contents:

  1. Interface vs Abstract Class (general OO)
  2. Interface vs Base class
  3. When to use an interface instead of an abstract class and vice versa?
  4. What does “program to interfaces, not implementations” mean?
  5. Why would I want to use Interfaces? [closed]
  6. Why can’t I seem to grasp interfaces?
  7. Why do we use Interface? Is it only for Standardization? [closed]
  8. What is the definition of “interface” in object oriented programming
  9. When to use mixins and when to use interfaces in Dart?
  10. When to use interfaces or abstract classes? When to use both?
  11. When to implement an interface and when to extend a superclass?
  12. What is an interface in Java?
  13. Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?
  14. What is the difference between an interface and a class, and why I should use an interface when I can implement the methods directly in the class?
  15. Monad in plain English? (For the OOP programmer with no FP background)
  16. Difference between object and instance
  17. Is it possible to access struct fields from within a trait?
  18. What is the point of interfaces in PHP?
  19. Does functional programming replace GoF design patterns?
  20. What is the scope of the Single Responsibility Principle? [closed]
  21. How much work should be done in a constructor?
  22. What is an example of the Single Responsibility Principle? [closed]
  23. Mediator Vs Observer Object-Oriented Design Patterns
  24. Doctrine2 ORM does not save changes to a DateTime field
  25. Can’t seem to understand SOLID principles and design patterns [closed]
  26. Why not use instanceof operator in OOP design?
  27. A use for multiple inheritance?
  28. In SOLID, what is the distinction between SRP and ISP? (Single Responsibility Principle and Interface Segregation Principle)
  29. When to use a Class in VBA?
  30. VBA: how to test for object equality (whether two variables reference the same object)

Leave a Comment