### Introduction

Once upon the time,

there was a Web Developer who used to spend weeks and weeks updating the same lines of code.

This caused him very bad headaches.

One day browsing between blogs’ post he came across the words Object Oriented Programming and what happened next is astonishing…

In the previous post, you discovered the [basics of the OOP paradigm in PHP](http://anastasionico.uk/blog/object-oriented-programming-in-php),

From its simple syntax to the advantages of reusing the same code in a straightforward still powerful way.

**Today you will learn how to best manage these objects and create long and safe relationships among them using inheritance and interfaces.**

### Inheritance

### What are inheritances on OOP?

We are now entering in one of the 4 basic pillars of Object Oriented [Programming](https://hackernoon.com/tagged/programming) in [PHP](https://hackernoon.com/tagged/php).

Inheritance alongside encapsulation, abstraction, and polymorphism need to be mastered to become proficuous in programming and really improve your skills.

**What inheritance does is relate classes to each other in a parent-child model.**

This is very useful when extraction characteristics that the related classes must have in common and allow to implement further methods and properties without rewrite the same again.

![](https://hackernoon.com/hn-images/0*luE-nXA0YdYBSY3e.jpg)

Like the last post let’s still use the _Building_ class as an example,  
In this example, we are presuming that when you want to instantiate a new building the work to build it have been completed and it is open to the public.

    class

    {

        $inConstruction

        $isOpen

        function

        {

            return

        }

        function

        {

            return

        }}

    class

    {

    }

    class

    {

        $isOpen

    }

We have three classes here,

the parent class which is the Building class and its children that inherit the building features, both properties, and methods.

We can now instantiate specific Schools and Offices rather than an abstract class Building

    $mySchool

    $myOffice

    echo

    echo

As you can see I haven’t actually written anything inside the School class but it still inherits all the property and methods of its parent class Building.

**This principle is called DRY (Don’t repeat yourself) and its goal is to reduce the text we write time and time again.**

I am sure you have also notice that the _Office_ class has a different value on the _$isOpen_ variable than its parent,

in fact,

by writing the same property or method in the of the parent into the child we overwrite its functionality.

Basically,

when instanciated _$myOffice_ is closed instead_$mySchool_ follow the behavior of Building and remain _$isOpen_ remain false (_$mySchool_ is open to visit).

### Why use inheritance?

There are several currents of thought about this topic,

someone says inheritance is good, some senior developer will kill you if you just think to use it in a live project,

I think that as most of the time the truth stays in the middle.

**Inheritance is an amazing way to save time avoiding to write the same things over and over again**,

it is very simple to understand and for a novice in OOP is the right path to follow.

It is also true that **inheritance has several limitations**and for an experienced web developer, there are quite a few better choice, one upon all composition.

Have a look at this video from Fun Fun Function

![](https://i.ytimg.com/vi/wfMtDGfHWpA/hqdefault.jpg)

My advice is to use inheritance as long as you are 100% comfortable with this technique, you understand how to use it, when to use it to share functionalities and when instead use other technique like composition, design patterns (the factory pattern is a really close case), or even just add a trait to the class.

### The extends keyword

Nobody knows why the keyword to create inheritance is not inherits or something more consistent and easy to remember but here we are.

**To allow a class inherits from another class we need to specify the keyword “extends” and the parent class just after the name of the child class and before the opening braces.**

![](https://hackernoon.com/hn-images/0*Gr6w9_wqIiUEW1U_.jpg)

A situation to be careful about is that a child class must always depend only on a single parent class, which mean multiple inheritances is not supported.

Think about it in this way:  
The Office class we use in the previous example cannot inherit features from the Building class and the Animal class in the same moment.

They just have no characteristics in common.

### The “final” keyword

The final keyword is are really easy concept introduced for the first time in php5.

In simple words,

it prevents method or classes to be extended.

Let’s see a quick example.

Presume that the mayor of our imaginary city decided that all the building must have at least an emergency exit and now look at the following sample of the code.

    class

    {

        ...

        function

        {

            $this->fireExtinguisherCount = 1;

        }

    }

    class

    {

        function

        {

            $this->fireExtinguisheCount = 0;

        }}

In this case,

the _setFireExtinguisher()_ method of the _Office_ class has overwritten the _Building_ class and set the _fireExtinguisheCount_ to 0,

Which as the mayor decided it is illegal.

A way to prevent it and avoid the architects to go to jail it to add the final keyword to the method.

    class

    {

        ...

        final

        {

            $this->fireExtinguisherCount = 1;

        }

    }

    class

    {

        function

        {

            $this->fireExtinguisheCount = 0;

        }

    }

Now the code of the _setFireExtinguisher()_ method of the _Office_ class cannot be used and it will actually result in a Fatal error _“Cannot override final method Building->setFireExtinguisher()”_.

Very simple concept, very easy implementation.

There is only a rule in this section of the article:

You cannot use final on attributes.

Attributes are variables and as the name suggests they need to be able to vary.

You can use final on classes that you do not want to be extended or methods that must not be overwritten.

### Interfaces

What are the mandatory steps that architects and constructors need to follow in order to create a building?

There are several regulations the need to be followed especially in public areas such us add several first aids, set evacuation plans up, etc.

An interface lets you arrange this steps in advance and oblige the classes to implement them accordingly.

**In a very simplistic way if a class is a blueprint of an object you can think of an interface like a blueprint for classes.**

Think at Interface as a pure template.

Let me explain,

Why do you need object interfaces in the first place?

**in PHP Interfaces define which methods a class must implement,**

**At the same time interfaces do not specify how these methods need to be implemented,**

you will see soon that the last sentence gives you a lot of freedom when managing your classes.

### The “interface” keyword

The syntax to create interfaces is almost the same as the one to create classes,

Naming an interface usually follow some conventions that will make it easier for others to understand your code, the most used convention are:

*   ThingInterface;
*   IThing;
*   I\_Thing;

In the following example, I am going to create interfaces that I will use in the _Building_ class.

The already-famous mayor of our city is very concerned about security and he decided that every building in our city must have a fire alarm and an assembly point in case of calamity.

Let’s code those interfaces.

    interface

    {

        function

    }

    interface

    {

        function

    }

There are two things that you should notice in the previous snippet,

the first one is that interfaces look very similar to classes,

the second is that there are no braces that open the block of code in the methods, the reason is that interfaces do not determinate how methods need to be implemented they just determinate what methods need to be implemented.

### The “implements” keyword

Now that the interfaces have been created we need to implement them in our _Building_ class.

To implement an interface you need to use the implements keyword.

A fundamental particularity important that you have to take note about is that: **all the methods in the interfaces must be included in the classes that implement the interface**.

This is a mandatory rule, and there is no exception;

PHP will let you know if you forgot methods by throwing a fatal error on the screen.

    class

    {

        function

        {

            $this->fireAlarm = true;

        }

    }

As said, all methods in the interface must be implemented within a class;

failure to do so will result in a fatal error.

Unlike inheritance, a class may implement more than one interface.

In fact,

if desired you can list as many interfaces as you like by listing them and separate each interface with a comma.

    class

    {

        …

    }

Although this is a very impressive feature of PHP, let me highlight once again that each method of each interface implemented must be included within the class and this can lead to a lot of disorder.

So be parsimonious with your interfaces and use them only after you have studied all the incoming problems that can take place.

### List of built-it interface included in PHP

PHP has a handful of interfaces integrated into the language.

Although the majority of them will be unlikely to be used on a day to day basis some could be very useful and will definitely save you some time during the development process of your project.

### Traversable

As the name suggests the **_Traversable_ interface analyzes a class and return a boolean value depending if the class that is implementing the traversable using a foreach**.

This interface has no methods, its intent is to be a foundation for traversable classes.

    Traversable {

    }

You can use this interface in your conditional statement to check if something is usable if a foreach.

Here is a quick example

    if( $buildings

        foreach

            …

        }

    }

Notice that the interface does not work on arrays and objects,   
which means you cannot user _Traversable_ to check if a variable of these types can be used in an array.

Why do you even need to verify them in the first place?

### Iterator

This _interface_ works on object or iterators that can repeat themselves.

The sentence above simply means that you can extend the _Iterator_ interface to whichever element that is traversable and include the following methods on the class.

    Iterator extends

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

    }

Understood??  
Here There is a real sample of how this interface might be really used for:

    public

    {

        $this->position = 0;

    }

    public

        return

    }

    public

        return

    }

    public

        ++$this->position;

    }

    public

        return

    }

### IteratorAggregate

The _IteratorAggregate_ interface is simply another method to implement an Iterator in your code.

    IteratorAggregate extends

        function

        {

        }

    }

The benefit of using this interface is the speed,

In fact, _IteratorAggregate_ is much faster than other options,

you need to notice that despite the name this is not an Iterator but it is a _Traversable_.  
which means there are no next, key, current, valid, rewind methods available.

### Throwable

The _Throwable_ interface is used for all the objects that can be thrown via the throw statement,  
They include Errors and Exception.  
Here is the interface and its complete list of methods:

    interface

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

        function

        {

        }

    }

PHP cannot implement this interface directly,

it can only be extended via Exception.

[![](https://hackernoon.com/hn-images/1*8FKpkkhRhWP0iLk7FpzTbQ.jpeg)](http://eepurl.com/dIZqjf)

### Conclusion of second part

![](https://hackernoon.com/hn-images/0*L0zKla3y-khFYODf.jpg)

[The full version of “**The complete guide to Object-Oriented Programming**” in an all-in-one edition is available in a Kindle format on Amazon](https://www.amazon.co.uk/dp/B07J47L6PB)

However do not worry, the following parts will be published in the following weeks.

… The Web Developer truly believed that he was very good in his job, and to be honest he was right.

He was already able to create everything passed from his mind, he could create applications from scratch and even difficult systems that make his boss and his clients happy,

What he realized is that his field is a no-stop learning, and after one thing there is another, then another, then another.

Today you are like him,

you have learned the [_OOP basics_](http://anastasionico.uk/blog/object-oriented-programming-in-php), now you know some more keywords, tomorrow you’ll soak in other information.

**Programming never ends, the less you think you know the better you become.**

In which part of your development knowledge are you?  
Do you already learn everything or you just step in OOP principles?

Let me know in the comment below…

_If you like this content and you are hungry for some more_ [_join the Facebook’s community_](https://www.facebook.com/anastasionico.uk/) _in which we share info and news just like this one!_

Alongside

Amazon

Assembly

Facebook

Rewind

Read My Stories

Too Long; Didn't Read

Cassandra Forward a free Cassandra-focused community event

Inheritance and Interfaces in PHP

Too Long; Didn't Read

People Mentioned

Companies Mentioned

@anastasionico

RELATED STORIES