PHP OOP Part-5: Abstraction and Interface

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the abstraction and interface in PHP. Let's begin the journey of learning PHP OOP together!

What is Abstraction in PHP?

We know that in Object-Oriented Programming, Abstraction is an important concept. So, what is abstraction? Abstraction refers to hiding the implementation details of a program, showing only its functionalities.

Now, let's try to understand how abstraction works in PHP. First, we will look at a simple example where there will be a parent class, and one or more child classes will inherit from this parent class. After that, we will discuss the drawbacks of this approach.

Code Example

class Vehicle
{
   public function getBaseFare()
   {
      // implementation
   }

   public function getPerKiloFare()
   {
      // implementation
   }

   public function getTotalFare()
   {
      // implementation
   }
}


class Car extends Vehicle
{
   // Car implementation
}

class Bike extends Vehicle
{
   // Bike implementation
}

Here we can see that the Vehicle class is being inherited by the Car and Bike classes. As a result, both of these classes gain access to the methods present in the Vehicle class. However, there is a problem: the methods in the parent class come with their implementations, which the child classes inherit. This means that all the child classes will share a common implementation and behave the same way. But this shouldn't be the case because the behavior of a Car should be different from that of a Bike. However, since we inherited the methods from the parent class, both classes are behaving the same way.

Now, what can we do if, after inheriting these common methods, we want them to behave differently for each class?

To solve this problem, PHP provides the Abstract class. What is an Abstract class?

An Abstract class is a type of class that can have both abstract methods and non-abstract methods. So, what are abstract and non-abstract methods?

Abstract methods are methods that only have a definition but no implementation. As a result, when a child class inherits the parent class, it must provide an implementation for the abstract methods of the parent class.

Non-abstract methods are methods that have both a definition and an implementation in the parent class. The child class simply inherits these methods and can use them.

Now, we will try to solve the above problem using an Abstract class.

Code Example

abstract class Vehicle
{
   abstract public function getBaseFare();

   abstract public function getPerKiloFare();

   public function getTotalFare()
   {
      echo $this->getBaseFare() + $this->getPerKiloFare() . "\n";
   }
}


class Car extends Vehicle
{
   public function getBaseFare()
   {
      return 20;
   }

   public function getPerKiloFare()
   {
      return 10;
   }
}

class Bike extends Vehicle
{
   public function getBaseFare()
   {
      return 10;
   }

   public function getPerKiloFare()
   {
      return 5;
   }
}

$car = new Car();
$car->getTotalFare();

$bike = new Bike();
$bike->getTotalFare();

Here we can see that there is a class named Vehicle. If we want to make a class abstract, we need to use the abstract keyword before the class name. So, the Vehicle class is an abstract class. Similarly, if we want to make a method in an abstract class, we need to use the abstract keyword before the method name. It is important to note that if we want to make any member of a class abstract, that class must also be an abstract class.

Now, the abstract methods inherited from the Vehicle class have been implemented differently in each child class. As a result, these methods will behave differently and provide different results for each child class.

Now, we might wonder why we had to abstract the methods getBaseFare and getPerKiloFare in the parent class when we could have simply implemented them directly in the child classes.

If you pay close attention, you'll notice that in the parent class, the methods getBaseFare and getPerKiloFare are used within another method. But if we hadn't abstracted getBaseFare and getPerKiloFare and had only implemented them in the child classes, we would not have had access to them in the parent class. Therefore, methods that need to be accessed by both the parent and child classes, and whose behavior should be different in each child class, are abstracted.

It is important to note that an abstract class cannot be instantiated directly. Instead, it is accessed through the child class, and the abstract methods inherited from the abstract class must be implemented in the child class. If this is not done, nothing in the child class will work. I hope this gives you a better understanding of how to use abstract classes.

What is Interface in PHP?

In the previous discussion, we talked about abstract classes. From that, we learned that when inheriting abstract methods from an abstract class, those methods must be implemented in the child class; otherwise, nothing in the child class will work.

But what if, in a child class, one of the abstract methods is not needed, but it still has to be implemented? This wouldn't be a good solution. So, what can we do in this case?

In this situation, we can use interfaces. An interface is similar to an abstract class, but an abstract class is not fully abstract because, as we know, an abstract class can have both abstract and non-abstract members.

On the other hand, an interface can only have abstract members. As a result, an interface is considered a fully abstract class. Now, we will try to solve the above problem using an interface.

Code Example

interface HourlyRentable
{
   public function getHourlyRate();
}

abstract class Vehicle
{
   abstract public function getBaseFare();

   abstract public function getPerKiloFare();

   public function getTotalFare()
   {
      echo $this->getBaseFare() + $this->getPerKiloFare() . "\n";
   }
}


class Car extends Vehicle implements HourlyRentable
{
   public function getBaseFare()
   {
      return 20;
   }

   public function getPerKiloFare()
   {
      return 10;
   }

   public function  getHourlyRate()
   {
      echo "Hourly 2 Dollar";
   }
}

class Bike extends Vehicle
{
   public function getBaseFare()
   {
      return 10;
   }

   public function getPerKiloFare()
   {
      return 5;
   }
}

$car = new Car();
$car->getTotalFare();

$bike = new Bike();
$bike->getTotalFare();

Here in the interface, we see the declaration of the getHourlyRate function. Then, in the Car class, we use (implement or inherit) this interface and provide the implementation of the abstract method inside the interface. However, in the Bike class, we didn’t have to implement this method because we didn’t use (implement or inherit) the interface in the Bike class. But if this abstract method had been inside an abstract class, we would have been forced to implement this method in both child classes, even if it wasn’t needed, which would have resulted in a bad design. Additionally, interfaces have various other use cases.

I hope this episode has provided you with a basic understanding of the discussed topics. That’s all for today. We’ll talk again in the next lesson.

You can connect with me on GitHub and Linkedin.