As a PHP developer, you can probably be forgiven if you have not yet stumbled across or made use of interfaces. It’s a technique that is often overlooked in the PHP world, although it is becoming more common-place.
With that in mind, I’m sure you’d agree that it is probably worth spending a couple of minutes to figure out what an interface is and when you should consider using one.
So, what is an interface?
Often described as a contract, an interface ensures that all implementing classes provide specific methods. In other words, if your class implements an interface, then it is promising to provide some specific functionality. This is useful if other classes are going to be using the class since they can be sure that certain features will be available.
When using an interface, implementing classes become interchangable with one another. As an example, let’s imagine that ‘Class A’ & ‘Class B’ implement ‘Interface Z’ which enforces the method ‘helloWorld()’. ‘Class C’ accepts ‘Interface Z’ as a parameter & then calls the ‘helloWorld()’ method.
The two implementing classes (A & B) could have very different implementations, and as such the results from calling their ‘helloWorld()’ method could also be very different. ‘Class C’ doesn’t care about this and both objects could be injected into it. So long as the object passed in implements ‘Interface Z’ , ‘Class C’ can utilise it (in this example by calling the ‘helloWorld()’ method).
I realize that the above sentences are probably little more than gibberish, so there’s a code example a little further down the page that will hopefully make it easier to comprehend!
How do interfaces differ from abstract classes?
If you are familiar with abstract classes, interfaces work in a vaguely similar way, providing a blueprint for classes which use them. This may sound confusing, as you are probably wondering why an interface is needed if abstract classes serve a similar purpose.
Well, abstract classes are normally used when you need to provide some basic, or common functionality which can then be extended or modified by derived classes. I like to think that an abstract class defines the core identity of a class. Any derived classes are of the same type, as an example, you may have an abstract ‘Animal’ class and a dervied ‘Dog’ class. An interface on the other hand defines how the class will interact with the outside world, and can be used by a wide range of object types. As an example, you may have a ‘Moveable’ interface, which both ‘Animal’ and ‘Vechile’ types can implement.
Additionally, it is not possible for a class to extend multiple abstract classes, whereas it is possible to implement multiple interfaces.
Recap/Notes:
- An interface can be used to enforce a single method, or multiple methods. Also, just to reiterate, an interface defines what methods a class MUST have, but it is still possible to add additional methods outside of this enforcement.
- In PHP an interface contains method declarations only – the method itself will be empty. This is in contrast to abstract classes, where it is possible to add some logic to methods which can then be overloaded/overridden in sub-classes.
- An interface expresses an ‘HAS A’ relationship, while an abstract class expresses an ‘IS A’ relationship.
Example:
I find it’s often easier to understand these concepts when given something to look at, so here is an example which demonstrates usage of an interface.
Below is a simple interface which will enforce one method upon the classes which implement it.
interface RendererInterface {
public function render();
}And here are a couple of classes making use of the interface.
class JsonRenderer implements RendererInterface {
public function render() {
}
}
class XMLRenderer implements RendererInterface {
public function render() {
}
}Notice both classes contain the render method, if they did not, then an exception would be thrown. When using these classes throughout your application you can now be sure that each has a render method, and as such they become interchangeable. You could, as an example, do something similar to the below:
class blogPost {
function __construct(RendererInterface $renderer) {
$this->renderer = $renderer;
}
function render() {
return $this->renderer->render();
}
}The above class now has the ability to render it’s contents in many different formats. This is made possible by injecting a ‘renderer’ class (which implements ‘RendererInterface’) into it. If you are unfamiliar with interfaces, you may also be unfamiliar with type-hinting. If this is the case, then the parameter passed into the constructor probably looks a little unusual, since it’s using type hinting!
In a nut-shell, type-hinting allows you to restrict a parameter to a specified type. This makes sense when the code used inside the function or class relies on the type of object passed in. Since we are assigning the object to a class property and then calling a specific method(render), our class is relying on the fact that the method exists. By typing-hinting the parameter to an object type of ‘RendererInterface’, it is possible to safely assume that the call to the render method(‘return $this->renderer->render()’) will be valid. As an added bonus, this now means that it’s possible to pass in absolutely any type of object, so long as it implements the interface.
Use of type hinting generally makes life easier for developers and those maintaining the code-base. Your IDE (if you are using a decent one) will have the ability to provide code completion, and it also self documents the parameter for developers working on the project in future; they instantly know that rendering the blogPost in a different format is as simple as creating a new class which implements the interface defined in the constructor.
Are interfaces truly needed in a dynamically typed language such as PHP?
Essentially the answer to that is no – they are not compulsory. Taking the above example, the code code be modified like so.
class blogPost {
function __construct($renderer) {
$this->renderer = $renderer;
}
function render() {
return $this->renderer->render();
}
}Assuming that the object passed in via the constructor had a ‘render’ method, then this code would work just fine. This is because PHP is a dynamically typed language, as opposed to a strictly typed language such as Java.
Although it’s not a requirement, it’s still wise to use interfaces where possible. As an example, you may often find yourself spending a lot of time on manual validation, such as using the ‘is_object()’, or ‘method_exists()’ functions throughout your classes to verify that the correct type/object has been passed in. Using an interface with type-hinting removes the need for this manual work. It also makes the code easier to maintain as mentioned earlier in the article!
Thanks for reading, and if you have any queries pop them in a comment below and I’ll get back to you ASAP.
The post PHP: Interfaces, what are they and when should you use them? appeared first on Weebtutorials.