OOP Basics: Polymorphism

The word Polymorphism comes from Greek and literally means "many forms" or the ability to take on multiple forms. In object-oriented programming, this means that different classes can implement the exact same method name, but each executes it in its own specific way. When we call this method, PHP automatically determines behind the scenes which object it belongs to and runs the correct code.

Real-World Analogy: The "PLAY" Button

Imagine a universal remote control with a PLAY button. This button is a single method that you can press on different devices (objects):

If the remote is connected to YouTube, the PLAY button will start a video stream.
If it is connected to Spotify, the same button will play music.
If you point it at a DVD player, it will spin a physical disc.

The command or method call is always completely identical (play()), but the final result depends on the device you are controlling. This is polymorphism in practice!

EXAMPLE

[file:Polymorphism with Inheritance (Return)]
<?php
class Animal {
 public function makeSound() { return "Some sound"; }
}
class Dog extends Animal {
 public function makeSound() { return "Woof woof"; }
}
class Cow extends Animal {
 public function makeSound() { return "Moo"; }
}
function playAnimalSound(Animal $animal) {
 return $animal->makeSound();
}
$dog = new Dog();
$cow = new Cow();
echo "The dog says: " . playAnimalSound($dog) . " ";
echo "The cow says: " . playAnimalSound($cow) . " ";
?>

[file:Polymorphism with Interfaces (Interface)]
<?php
interface Shape {
 public function draw();
}
class Circle implements Shape {
 public function draw() { echo "Drawing a circle... "; }
}
class Square implements Shape {
 public function draw() { echo "Drawing a square... "; }
}
function render(Shape $shape) {
 $shape->draw();
}
$circle = new Circle();
$square = new Square();
render($circle);
render($square);
?>

[file:Polymorphism with Abstract Classes]
<?php
abstract class Payment {
 abstract public function calculateFee($amount);
}
class CreditCard extends Payment {
 public function calculateFee($amount) { return $amount * 0.02; }
}
class Cash extends Payment {
 public function calculateFee($amount) { return 0; }
}
function printCost(Payment $method, $amount) {
 echo "The fee is: " . $method->calculateFee($amount) . " EUR ";
}
$visa = new CreditCard();
$cash = new Cash();
echo "Credit Card (100€): "; printCost($visa, 100);
echo "Cash (100€): "; printCost($cash, 100);
?>

RESULT

The result will be displayed here...

Why is Polymorphism So Useful?

The main power of polymorphism lies in the fact that it allows us to write extremely flexible code. We can create a single main function that accepts a general type (e.g., an interface or a parent class), and then we can pass any subclass to it without changing the code.

If you were to add a new class to your application in the future (e.g., ElectricScooter), you would not need to change the existing functions for driving. As long as the scooter follows the same rules and has a method for moving, the system will work without a single modification!

Quick Comparison: Inheritance vs. Polymorphism

Beginners often confuse these two terms because they are closely related. Take a look at their mutual relationship:

OOP Concept	Main Goal	Approach in Code
Inheritance	Code reuse (DRY).	A child takes code from the parent so it does not have to be rewritten.
Polymorphism	Flexibility and a unified interface.	Different children have methods with the same name but completely different behavior.