Polymorphism in PHP OOP allows different classes to be treated as objects of a common superclass or interface while maintaining their unique behaviors. 1. It is achieved primarily through method overriding, where a subclass redefines a method from its parent class, enabling distinct responses to the same method call. 2. Interfaces also enable polymorphism by defining a contract that multiple classes can implement in different ways. 3. Type hinting ensures that functions accept objects conforming to a specific interface or superclass, allowing flexible yet consistent code design. This leads to scalable and maintainable applications where new types can be added without altering existing logic.

Polymorphism in PHP OOP refers to the ability of different classes to be treated as objects of a common superclass, while still maintaining their own unique behaviors. This means you can interact with various objects through the same interface, but each object responds differently depending on its actual class.

It’s one of the four pillars of Object-Oriented Programming (OOP), along with inheritance, encapsulation, and abstraction.

Method Overriding

One of the main ways polymorphism is achieved in PHP is through method overriding. That’s when a child class redefines a method that already exists in its parent class.

For example:

class Animal {
    public function makeSound() {
        echo "Some generic sound";
    }
}

class Dog extends Animal {
    public function makeSound() {
        echo "Bark!";
    }
}

class Cat extends Animal {
    public function makeSound() {
        echo "Meow!";
    }
}

In this case, both Dog and Cat inherit from Animal, but they override the makeSound() method. So when you call makeSound() on an instance of Dog or Cat, it behaves differently — even though the calling code might just think it's working with an Animal.

This allows for flexible and scalable code where new types can be added without changing existing logic.

Using Interfaces

Another way to achieve polymorphism is by using interfaces.

An interface defines a contract — a list of methods that a class must implement. Different classes implementing the same interface can provide their own version of those methods.

Here’s a simple example:

interface Shape {
    public function area();
}

class Circle implements Shape {
    private $radius;

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

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

class Rectangle implements Shape {
    private $width;
    private $height;

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

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

Now, you can write code that works with any Shape without knowing whether it’s a Circle or Rectangle. For example:

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

This function will work with any class that implements the Shape interface — that’s polymorphism in action.

Type Hinting and Polymorphic Behavior

PHP supports type hinting, which lets you specify what type of object a function expects. This helps enforce polymorphic behavior.

You can type hint with either:

• A parent class
• Or an interface

This ensures your functions accept only compatible types while allowing flexibility in the actual implementation.

So in the earlier examples, we used printArea(Shape $shape) — this guarantees that whatever gets passed in conforms to the Shape interface, but how it calculates area depends on the actual object.

Summary

To sum up, here’s how polymorphism works in PHP OOP:

• It allows different classes to be used interchangeably if they share a common interface or parent class.
• Method overriding lets subclasses redefine inherited methods.
• Interfaces define a set of methods that multiple classes can implement differently.
• Type hinting helps maintain consistency while enabling flexibility.

And that’s basically it. Not magic, just smart design.

The above is the detailed content of What is polymorphism in php OOP and how is it achieved?. For more information, please follow other related articles on the PHP Chinese website!