When should you make an interface/contract, and when not? [closed]

by

Interfaces are public “contracts” whenever you want to be able to swap the implementation or give someone the flexibility to use another implementation you should use interfaces.

Example:

You want to store something so you can load it later.
You could use something like

public function save(MySQL $db, array $data);

But this is not very flexible and it ties you code to a MySQL implementation.
If you want to be open for other implementations, because you are building an public library or framework or whatever, you should do something like this.

public function save(Persistance $storage, array $data)
{
    // dome some random stuff with you data
    ...
    $storage->save($data);
}

In this case Persistence is an interface and it could look something like this.

interface Persistance
{
    public function save(array $data);
}

And you local implementation could look like this.

class MySQL implements Persistance
{
    public function save(array $data)
    {
        $this->insert('my_table', $data);
    }
}

But somebody else could use your code with a complete different persistence layer, Redis or Postgres for example, just by implementing your interface and injecting their own Persistence implementation.

This is just a simple example, but Interfaces are mostly to understand as contracts between classes and leave the implementation open.

The opportunity to implement multiple interfaces is nice but has nothing to do with multiple inheritance. Interfaces only make sure a class has some clearly defined in- and outputs, but how things are done in the background is completely open.

If you really want get into ‘multiple inheritance’ you should have a look at Traits.

Interfaces are used in frameworks and the PHPFig is defining a lot of standard interfaces lately to make framework components more exchangeable.

For example the PSR-16 simple cache interface makes it possible to exchange the cache layer implementation between frameworks.

Or the PSR-7 Request Response interface enables frameworks to exchange standardized middleware implementations for login, CRF security or other stuff.

There is a PSR-11 Interface for dependency injection containers, if frameworks change their implementation from their own DI container to the interface we will be able to use those frameworks with different DI container implementations.

More Related Contents:

  1. What is the point of interfaces in PHP?
  2. Interface or an Abstract Class: which one to use?
  3. Interface implementation: declaration must be compatible
  4. remove duplicate key array from php [duplicate]
  5. When should I use ‘self’ over ‘$this’?
  6. Is there a use-case for singletons with database access in PHP?
  7. What does the variable $this mean in PHP?
  8. How to use PDO connection in other classes?
  9. MVC for advanced PHP developers [closed]
  10. What does it mean to start a PHP function with an ampersand?
  11. What is the best method to merge two PHP objects?
  12. Get PHP class property by string
  13. Best practice on PHP singleton classes [duplicate]
  14. PHP OOP core framework
  15. Multiple Inheritance in PHP
  16. Accessing Class Properties with Spaces
  17. Is it possible to create static classes in PHP (like in C#)?
  18. When should I declare variables in a PHP class?
  19. Autoload classes from different folders
  20. If Singletons are bad then why is a Service Container good?
  21. When should I use stdClass and when should I use an array in php oo code?
  22. How to use class methods as callbacks
  23. Chaining Static Methods in PHP?
  24. Dynamically create PHP object based on string
  25. Nested or Inner Class in PHP
  26. Performance of static methods vs. functions
  27. Call method by string?
  28. How to create a fluent query interface?
  29. Traits vs. interfaces
  30. PHP equivalent of friend or internal

Leave a Comment