Polymorphism in PHP With Example

Mohasin Hossain
3 min readJan 1, 2024

Let’s learn about Polymorphism in PHP.

Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common base class. PHP supports polymorphism through method overloading and interfaces.

Method Overloading:

  • In PHP, method overloading is achieved by having multiple methods in a class with the same name but different parameters.
  • PHP doesn’t support native method overloading by changing the number or type of parameters, but you can use default parameter values or variable-length argument lists (func_num_args(), func_get_arg(), and func_get_args()) to achieve a similar effect.
class Calculator {
public function add($a, $b) {
return $a + $b;
}

public function add($a, $b, $c) {
return $a + $b + $c;
}
}

$calc = new Calculator();
echo $calc->add(2, 3); // Outputs 5
echo $calc->add(2, 3, 5); // Outputs 10

Interfaces:

  • PHP allows you to define interfaces, which are a set of method signatures that a class must implement.
  • When a class implements an interface, it must provide concrete implementations for all the methods declared in the interface.
interface Shape {
public function calculateArea();
}

class Circle implements Shape {
private $radius;

public function __construct($radius) {
$this->radius = $radius;
}

public function calculateArea() {
return pi() * $this->radius * $this->radius;
}
}

class Square implements Shape {
private $side;

public function __construct($side) {
$this->side = $side;
}

public function calculateArea() {
return $this->side * $this->side;
}
}

$circle = new Circle(5);
echo $circle->calculateArea(); // Outputs the area of the circle

$square = new Square(4);
echo $square->calculateArea(); // Outputs the area of the square

Polymorphism allows you to write more flexible and reusable code by treating objects of different classes in a unified way, as long as they adhere to a common interface or share method names.

Abstract Class:

// Shape.php
abstract class Shape {
abstract public function calculateArea();
}

// Circle.php
class Circle extends Shape {
private $radius;

public function __construct($radius) {
$this->radius = $radius;
}

public function calculateArea() {
return pi() * $this->radius * $this->radius;
}
}

// Square.php
class Square extends Shape {
private $side;

public function __construct($side) {
$this->side = $side;
}

public function calculateArea() {
return $this->side * $this->side;
}
}

Now, let’s use polymorphism with these classes:

// Example usage in a controller or view

function printArea(Shape $shape) {
echo "Area: " . $shape->calculateArea() . PHP_EOL;
}

// Creating instances of Circle and Square
$circle = new Circle(5);
$square = new Square(4);

// Using polymorphism to calculate and print the area
printArea($circle); // Outputs the area of the circle
printArea($square); // Outputs the area of the square

In this example, the printArea function takes a parameter of type Shape, which is an abstract class. This function can accept any subclass of Shape, such as Circle or Square, due to polymorphism. The calculateArea method is called on the objects passed to printArea, and the correct implementation (either from Circle or Square) is invoked based on the actual type of the object at runtime.

Hope you enjoyed!

Bonus: You must love my most read article : How To Use Single Responsibility Principle in PHP/Laravel
And most GitHub star repo:
https://github.com/mohasinhossain/SOLID-Principles-in-PHP

--

--

Mohasin Hossain

Senior Software Engineer | Mentor @ADPList | Backend focused | PHP, JavaScript, Laravel, Vue.js, Nuxt.js, MySQL, TDD, CI/CD, Docker, Linux