PHP OOP Fundamentals - Polymorphism in PHP

In Object-Oriented Programming (OOP), polymorphism is one of the core concepts that allows for flexibility and reusability in code. It enables objects to be treated as instances of their parent class, while allowing for behavior that varies based on the specific type of object. In this blog post, we'll explore polymorphism in PHP, how it's implemented using the latest features of PHP (8.3), and why it's an essential tool for developing robust, scalable applications.

What is Polymorphism?

Polymorphism, derived from the Greek words poly (many) and morphos (forms), literally means "many forms." In the context of OOP, polymorphism refers to the ability of different classes to provide different implementations for methods that are defined in a shared parent class or interface. This concept allows objects of different types to be processed using the same method call, without knowing the exact type of the object at compile time.

Polymorphism promotes flexibility and modularity in code by allowing different objects to respond to the same method in different ways. The two primary types of polymorphism in PHP are:

Method Overriding (Run-time polymorphism)
Interface Implementation (Compile-time polymorphism)

Example of Polymorphism in PHP

Let’s explore an example using a scenario where multiple classes implement the same method in different ways. We'll work with an example involving different types of animals and how each responds to the speak() method.

<?php

// Parent class
class Animal {
    public function speak(): string {
        return "The animal makes a sound.";
    }
}

// Child class 1
class Dog extends Animal {
    public function speak(): string {
        return "The dog barks.";
    }
}

// Child class 2
class Cat extends Animal {
    public function speak(): string {
        return "The cat meows.";
    }
}

// Child class 3
class Cow extends Animal {
    public function speak(): string {
        return "The cow moos.";
    }
}

// Example of polymorphism
function animalSpeak(Animal $animal): void {
    echo $animal->speak() . PHP_EOL;
}

$dog = new Dog();
$cat = new Cat();
$cow = new Cow();

animalSpeak($dog); // Output: The dog barks.
animalSpeak($cat); // Output: The cat meows.
animalSpeak($cow); // Output: The cow moos.

Explanation

Parent Class: The Animal class defines a speak() method, which serves as the default behavior. This method is then overridden by the child classes (Dog, Cat, and Cow) to provide specific behavior for each type of animal.
Method Overriding: In each subclass (e.g., Dog, Cat), the speak() method is redefined to return a message specific to the animal's sound. This is known as method overriding, a key aspect of polymorphism.
Polymorphic Behavior: The animalSpeak() function accepts an Animal object as its argument. Even though this function expects an object of the type Animal, it can handle any subclass of Animal (such as Dog, Cat, or Cow). This is polymorphism in action: the method call (speak()) behaves differently depending on the type of the object passed to it.

By using polymorphism, we can write more flexible and reusable code. The animalSpeak() function doesn’t need to know the specific type of animal it’s dealing with, but it can still invoke the correct behavior (method) based on the object type.

Polymorphism Through Interfaces

Polymorphism can also be achieved using interfaces in PHP. Interfaces allow unrelated classes to implement the same set of methods. This approach is particularly useful when you want different classes to have the same behavior but don't share a common parent class.

Here’s an example demonstrating polymorphism using interfaces:

<?php

// Define an interface
interface Shape {
    public function area(): float;
}

// Class that implements the Shape interface
class Circle implements Shape {
    private float $radius;

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

    public function area(): float {
        return pi() * pow($this->radius, 2);
    }
}

// Another class that implements the Shape interface
class Rectangle implements Shape {
    private float $width;
    private float $height;

    public function __construct(float $width, float $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function area(): float {
        return $this->width * $this->height;
    }
}

// A third class that implements the Shape interface
class Triangle implements Shape {
    private float $base;
    private float $height;

    public function __construct(float $base, float $height) {
        $this->base = $base;
        $this->height = $height;
    }

    public function area(): float {
        return 0.5 * $this->base * $this->height;
    }
}

// Polymorphic function to calculate area of different shapes
function calculateArea(Shape $shape): void {
    echo "Area: " . $shape->area() . PHP_EOL;
}

$circle = new Circle(5);
$rectangle = new Rectangle(4, 6);
$triangle = new Triangle(3, 7);

calculateArea($circle);    // Output: Area: 78.5398
calculateArea($rectangle); // Output: Area: 24
calculateArea($triangle);  // Output: Area: 10.5

Explanation

Interface Definition: The Shape interface declares a method called area(), which all implementing classes must define. This ensures that all shapes have an area() method, even though the shapes might be implemented differently.
Interface Implementation: The Circle, Rectangle, and Triangle classes each implement the Shape interface. They provide their own versions of the area() method based on their specific geometric formulas.
Polymorphic Function: The calculateArea() function accepts an object that implements the Shape interface. It doesn't need to know whether it's dealing with a circle, rectangle, or triangle. This is another example of polymorphism—handling different types (shapes) with a unified interface.

This approach decouples the code and makes it more flexible. You can add more shapes in the future without changing the calculateArea() function, as long as those shapes implement the Shape interface.

Advantages of Polymorphism in PHP

Polymorphism offers several key benefits:

Code Flexibility and Reusability: With polymorphism, you can write more generic and reusable code that can handle objects of different types. This reduces duplication and allows for a cleaner, more maintainable codebase.
Modularity: You can introduce new classes or modify existing ones without affecting code that relies on polymorphic behavior. For example, you could add a new Square class to the Shape interface without changing the calculateArea() function.
Decoupling: By relying on interfaces and abstract classes, polymorphism reduces dependencies between classes. This leads to a loosely coupled system that is easier to refactor or extend.
Extensibility: Polymorphism makes it easier to extend your application by adding new behaviors or types without altering the existing code that uses polymorphic functions or methods.

Abstract Classes and Polymorphism

In addition to interfaces, PHP also supports polymorphism through abstract classes. Abstract classes serve as blueprints for other classes, containing both abstract methods (which must be implemented by child classes) and concrete methods.

Here’s an example using an abstract class:

<?php

// Abstract class with abstract method
abstract class Vehicle {
    protected int $speed;

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

    // Abstract method
    abstract public function getFuelType(): string;

    // Concrete method
    public function getSpeed(): int {
        return $this->speed;
    }
}

// Child class 1
class Car extends Vehicle {
    public function getFuelType(): string {
        return "Gasoline";
    }
}

// Child class 2
class ElectricCar extends Vehicle {
    public function getFuelType(): string {
        return "Electricity";
    }
}

// Example usage of polymorphism with abstract class
$car = new Car(120);
$electricCar = new ElectricCar(150);

echo $car->getFuelType();        // Output: Gasoline
echo $electricCar->getFuelType(); // Output: Electricity

Conclusion

Polymorphism is an essential concept in PHP OOP that allows developers to write flexible and reusable code. It promotes loose coupling, improves code extensibility, and makes it easier to manage complex applications. Whether you use method overriding, interfaces, or abstract classes, PHP offers powerful tools to implement polymorphism efficiently, especially with the latest syntax improvements in PHP 8.3.

By mastering polymorphism, you'll be better equipped to build scalable, maintainable applications that can easily adapt to changes and grow with your requirements.