Polymorphism

Introduction

Picture a media player that can play an `Mp3`, a `Podcast`, or a `Video`. Each one plays completely differently under the hood, yet you would like to write one simple loop that calls `play()` on whatever item comes next, without checking what type it is first. That is exactly the problem polymorphism solves.

The word literally means "many forms." In object-oriented PHP, it describes calling the same method name on different objects and getting behavior appropriate to each object's own class.

What Is Polymorphism?

Polymorphism means that calling the exact same method name on objects of different classes runs different code, appropriate to each class, without the calling code needing to know which class it is dealing with.

Method Overriding as the Mechanism

In PHP, polymorphism is achieved primarily through method overriding, which you saw in the previous lesson: subclasses of a shared parent (or implementers of a shared interface) each define their own version of the same method name.

<?php
abstract class Animal
{
    protected string $name;

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

    abstract public function speak(): string;
}

class Dog extends Animal
{
    public function speak(): string
    {
        return "{$this->name} says Woof!";
    }
}

class Cat extends Animal
{
    public function speak(): string
    {
        return "{$this->name} says Meow!";
    }
}

class Cow extends Animal
{
    public function speak(): string
    {
        return "{$this->name} says Moo!";
    }
}

Each subclass provides its own `speak()`. The method name never changes, but each class's version behaves differently — that difference in behavior, tied to a shared method name, is polymorphism.

Worked Example: Shared Method, Different Behavior

The real payoff of polymorphism shows up when you loop over a collection of different objects and call the same method on each, without any type-checking logic at all.

<?php
// Using the Animal, Dog, Cat, Cow classes from above

$animals = [
    new Dog("Rex"),
    new Cat("Whiskers"),
    new Cow("Bessie"),
];

foreach ($animals as $animal) {
    echo $animal->speak() . "\n";
}

Rex says Woof!
Whiskers says Meow!
Bessie says Moo!

The `foreach` loop treats every element identically — it only knows it has an `Animal` and calls `speak()` on it. There is no `if ($animal instanceof Dog) { ... } elseif ($animal instanceof Cat) { ... }` chain anywhere. Each object automatically runs its own version of `speak()`. This is what makes polymorphic code easy to extend: adding a new `Bird` class that also extends `Animal` and defines its own `speak()` requires no changes at all to the loop above.

Type Declarations Make It Safe

Polymorphism relies on every object in the collection genuinely being able to respond to the shared method. PHP's type declarations, combined with inheritance (or interfaces, covered next lesson), let you enforce this safely.

<?php
function announce(Animal $animal): void
{
    echo $animal->speak() . "\n";
}

announce(new Dog("Rex"));
announce(new Cat("Whiskers"));
// announce("not an animal"); // Fatal error: Argument must be of type Animal

Rex says Woof!
Whiskers says Meow!

Because the `announce()` function's parameter is typed as `Animal`, PHP guarantees at call time that whatever is passed in — a `Dog`, a `Cat`, a `Cow`, or any future subclass — really does have a `speak()` method available. That guarantee is what lets polymorphic code stay both flexible and safe.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Polymorphism lets you write simpler, more extensible code by calling one shared method name across many different object types, each responding in its own way. Combined with type declarations, it lets PHP enforce that every object really does support the behavior your code expects.