When are object interfaces useful in PHP? [duplicate]

This question already has answers here: 开发者_如何学Python What is the point of interfaces in PHP? (15 answers) Closed 8 years ago.

From php.net:

Object interfaces allow you to create code which specifies which methods a class must implement, without having to define how these methods are handled.

Why should I need to do that? Could it be a kind of 'documentation'?

When I'm thinking about a class I have to implement, I know exactly which methods I should code.

What are some situations where interfacing a class is a "best practice"?

---

Short answer: uniform interfaces and polymorphism.

Longer answer: you can obviously just create a class that does everything and indeed you'd know what methods to write. The problem you have with using just concrete classes, however, is your lack of ability to change. Say you have a class that stores your users into a MySQL database, let's call it a UserRepository. Imagine the following code:

<?php
class UserRepositoryMysql {
    public function save( User $user ) {
        // save the user.
    }
}

class Client {
    public function __construct( UserRepositoryMysql $repos ) {
        $this->repos = $repos;
    }

    public function save( User $user ) {
       $this->repos->save( $user );
    }
}

Now, this is all good, as it would actually work, and save the User to the database. But imagine your application will become populair, and soon, there is a question to support PostgreSQL as well. You'll have to write a UserRepositoryPostgresql class, and pass that along instead of UserRepositoryMysql. Now, you've typehinted on UserRepositoryMysql, plus you're not certain both repositories use the same methods. As an aside, there is little documentation for a potential new developer on how to implement his own storage.

When you rewrite the Client class to be dependent upon an interface, instead of a concrete class, you'll have an option to "swap them out". This is why interfaces are useful, obviously, when applied correctly.

---

First off, my php object coding is way behind my .net coding, however, the principles are the same. the advantages of using interfaces in your classes are many fold. Take for example the case where you need to return data from a search routine. this search routine may have to work across many different classes with completely different data structures. In 'normal' coding, this would be a nightmare trying to marry up the variety of different return values.

By implementing interfaces, you add a responsibility to the clsses that use them to produce a uniform set of data, no matter how disparate they may be. Another example would be the case where you are pulling data from different 'providers' (for example xml, json, csv etc, etc). By implementing an interface on each class type, you open up the possibilities to extend your data feeds painlessly by adding new classes that implement the interface, rather than having a mash-up of switch statements attempting to figure out what your intentions are.

In a word, think of an interface as being a 'contract' that the class 'must' honour. lnowing that means that you can code with confidence for that given scenario with only the implementation detail varying.

Hope this helps.

[edit] - see this example on SO for a fairly simple explanation:

An interface is a concept in Object Oriented programming that enables polymorphism. Basically an interface is like a contract, that by which classes that implement it agree to provide certain functionality so that they can be used the same way other classes that use the interface

purpose of interface in classes

---

The first case that comes to my mind is when you have a class that uses certain methods of another class. You don't care how this second class works, but expects it to have particular methods.

Example:

interface IB {
    public function foo();
}

class B implements IB {
    public function foo() {
        echo "foo";
    }
} 

class A {
    private $b;
    public function __construct( IB $b ) {
        $this->b = $b;
    }

    public function bar() {
        $this->b->foo();
    }
}

$a = new A( new B() );
$a->bar(); // echos foo

Now you can easily use different object passed to the instance of class A:

class C implements IB {
    public function foo() {
        echo "baz";
    }
}

$a = new A( new C() );
$a->bar(); // echos baz

Please notice that the same bar method is called.

You can achieve similar results using inheritance, but as PHP does not support multiple inheritance, interfaces are better - class can implement more than one interface.

You can review one of PHP design patterns - Strategy.

---

Say you're creating a database abstraction layer. You provide one DAL object that provides generic methods for interfacing with a database and adapter classes that translate these methods into specific commands for specific databases. These adapters themselves need to have a generic interface, so the DAL object can talk to them in a standardized way.

You can specify the interface the adapters need to have using an Interface. Of course you can simply write some documentation that specifies what methods an adapter needs to have, but writing it in code enables PHP to enforce this interface for you. It enables PHP to throw helpful error messages before a single line of code is executed. Otherwise missing methods could only be found during runtime and only if you actually try to call them, which makes debugging a lot harder and code much more unreliable.