A fundamental concept in object-oriented programming (OOP), PHP's polymorphism allows objects of different classes to be considered to be members of the same superclass. Through interfaces and method overrides, it provides the ability to do a single action in multiple ways. In this article, we will learn about Polymorphism in PHP with the help of examples.
What is Polymorphism?
The term polymorphism, which comes from the Greek words "poly" (many) and "morph" (shape), describes the ability of an object, function, or method to take on multiple forms. PHP achieves polymorphism through the use of interfaces, abstract classes, and method overriding. It allows programmers to define methods in a parent class or interface, which are subsequently implemented or overridden in child classes.
Polymorphism Features
- Flexibility: Because to polymorphism, programmers may write code that interacts with objects of different classes with ease.
- Reusability: Polymorphism-based code can often be used across different parts of an application.
- Expandability: It facilitates adding new functionality to a program without requiring modifications to the existing code.
Types of Polymorphism
- Compile-Time Polymorphism: A type of polymorphism known as "method overloading" allows many methods in the same class to have the same name but different parameters. Although method overloading isn't officially enabled by PHP, variable-length and default parameters may achieve the same objectives.
- Run-Time Polymorphism: Method overriding is the process by which a child class provides a specific implementation for a method that is declared in the parent class. This type of polymorphism is mostly supported by PHP.
Polymorphism with Method Overriding Example
<?php
// Parent class
class Animal
{
public function speak()
{
echo "The animal makes a sound.\n";
}
}
// Child class 1
class Dog extends Animal
{
public function speak()
{
echo "The dog barks.\n";
}
}
// Child class 2
class Cat extends Animal
{
public function speak()
{
echo "The cat meows.\n";
}
}
// Function that uses polymorphism
function makeAnimalSpeak(Animal $animal)
{
$animal->speak(); // Calls the appropriate method based on the object type
}
// Create objects
$dog = new Dog();
$cat = new Cat();
makeAnimalSpeak($dog); // Outputs: The dog barks.
makeAnimalSpeak($cat); // Outputs: The cat meows.
?>
Polymorphism Through Interfaces
Classes are bound by the contract defined by interfaces. Classes can define their own behavior while being viewed as objects of the same type by implementing an interface.
<?php
// Define an interface
interface Shape
{
public function calculateArea();
}
// Class implementing Shape for a Rectangle
class Rectangle implements Shape
{
private $width;
private $height;
public function __construct($width, $height)
{
$this->width = $width;
$this->height = $height;
}
public function calculateArea()
{
return $this->width * $this->height;
}
}
// Class implementing Shape for a Circle
class Circle implements Shape
{
private $radius;
public function __construct($radius)
{
$this->radius = $radius;
} public function calculateArea()
{
return pi() * pow($this->radius, 2);
}
}
// Function that demonstrates polymorphism
function displayArea(Shape $shape)
{
echo "The area is: " . $shape->calculateArea() . "\n";
} // Create objects
$rectangle = new Rectangle(4, 5);
$circle = new Circle(3); displayArea($rectangle); // Outputs: The area is: 20
displayArea($circle); // Outputs: The area is: 28.274333882308
?>
Let's take a Real-World Example of Payment Gateway System. Consider a system in which several payment options (such as BankTransfer, PayPal, and CreditCard) use a single PaymentProcessor interface. The system can call specialized implementations while treating all payment processors in a general manner.
<?php
interface PaymentProcessor
{
public function processPayment($amount);
}
class CreditCard implements PaymentProcessor
{
public function processPayment($amount)
{
echo "Processing a credit card payment of $amount.\n";
}
}
class PayPal implements PaymentProcessor
{
public function processPayment($amount)
{
echo "Processing a PayPal payment of $amount.\n";
}
}
function processOrder(PaymentProcessor $processor, $amount)
{
$processor->processPayment($amount);
}
// Usage
$creditCard = new CreditCard();
$paypal = new PayPal();
processOrder($creditCard, 100); // Outputs: Processing a credit card payment of 100.
processOrder($paypal, 150); // Outputs: Processing a PayPal payment of 150.
?>
Conclusion
PHP polymorphism is a useful tool for developing software that is flexible, reusable, and maintained. Through the use of abstract classes, interfaces, or method overrides, polymorphism enables programmers to write code that can adapt to a variety of scenarios without superfluous complexity. By understanding and applying this concept, you may make the most of PHP's object-oriented features to create reliable and scalable software solutions.
