PHP OOP Part-6: Polymorphism

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 Polymorphism in PHP. Let's begin the journey of learning PHP OOP together!

Now we will learn about polymorphism. What does polymorphism mean? The term "Polymorphism" has two parts. One is "Poly," which means many, and the other is "Morphism," which means forms. So, polymorphism means many forms or various forms. In the context of programming, when the term polymorphism is used, we can achieve it using two concepts.

The first concept is Method Overloading, which is also known as Compile-Time Polymorphism.

Method overloading works like this: Suppose we have a method in a class that takes one parameter. If we declare another method with the exact same name but with multiple parameters, it is valid. That means we can declare two methods with the same name in a class, but the number of parameters must be different. Later, when we create an instance of this class and use these methods, the decision of which method to call will depend on how many parameters are passed to it. As a result, the same method will behave or act differently based on the parameters. Now let’s take a look at an example code.

Code Example

class Vehicle
{
   public function getTotal($first, $second)
   {
      echo $first . " " . $second . "\n";
   }

   public function getTotal($first, $second, $third)
   {
      echo $first . " " . $second . " " . $third . "\n";
   }
}

$vehicle = new Vehicle();
$vehicle->getTotal(10, 20);
$vehicle->getTotal(10, 20, 30);

Here we can see that two methods named getTotal have been declared in the Vehicle class. These two methods take different parameters. Now, when we create an instance of the Vehicle class and use these methods, their behavior depends on the parameters provided. For example, after creating an instance of the Vehicle class, the getTotal method is first called with 2 parameters, resulting in the first getTotal method of the class being called. Then, the getTotal method is called again with 3 parameters, causing the second getTotal method of the class to be called. So, we can understand how the same method can behave differently.

However, if you run this code, it won’t work because PHP does not support method overloading or compile-time polymorphism. But it does support method overriding or runtime polymorphism. We only used this example to understand the concept theoretically.

The second concept is Method Overriding, also known as Runtime Polymorphism.

Method overriding works as follows: Suppose there is a method in a class that may or may not take parameters and performs a specific task. If this class is inherited by another class, and a method with the exact same name is declared in the child class, this process is called method overriding or runtime polymorphism. In other words, we can declare a method with the same name in the child class, and the number of parameters can be the same or different. It will perform a different task. Later, when we create an instance of the child class and use the method, the decision of whether to call the method from the parent or child class will depend on the parameters passed. As a result, the same method will exhibit different behaviors or actions based on the parameters. Now let’s take a look at an example code.

Code Example

class Vehicle
{
   public function getTotal($first, $second)
   {
      echo $first . " " . $second . "\n";
   }
}

class Car extends Vehicle
{
   public function getTotal($first, $second, $third = null)
   {
      echo $first . " " . $second . " " . $third . "\n";
   }
}

$vehicle = new Car();
$vehicle->getTotal(10, 20);
$vehicle->getTotal(10, 20, 30);

When the getTotal method is called with two parameters from the instance of the child class, it checks at runtime if such a method with two parameters exists in the child class. If not, the child class will inherit and call the method from its parent class.

Later, when the getTotal method is called again with three parameters, it checks once more if a method with three parameters exists in the child class. Upon finding that the method has been overridden in the child class with three parameters, it calls the getTotal method from the child class.

If both the parent and child classes have methods with the same parameters, the overridden method in the child class will be called in this case as well.

This is essentially how method overriding works. Now we understand how to override a method and how it operates.

I hope this discussion has provided you with a preliminary understanding of the topics covered in this lesson. That’s all for today; we’ll see you in the next lesson.

You can connect with me on GitHub and Linkedin.