How to implement polymorphism in PHP?

Polymorphism in PHP allows different objects to share the same interface while having unique behaviors. Implementation through interfaces and abstract classes: Interfaces define method signatures without providing implementations. The object must implement all methods in the interface. Abstract classes contain unimplemented methods that can only be implemented in subclasses. Practical example: Define the animal behavior interface AnimalActions. Define the abstract animal class Animal, which has abstract method makeSound. Create concrete animal classes Dog and Cat, implement AnimalActions and makeSound. Create a Zoo class to manage animals. Add animals to Zoo and execute their talk method, outputting "Buddy barks." and "Fluffy meows."

Polymorphism in PHP

Polymorphism is an important feature in object-oriented programming that allows different Objects share the same interface while maintaining their own unique behavior. In PHP, polymorphism can be achieved using interfaces and abstract classes.

Interface

An interface defines a list of method signatures without providing an actual implementation. Objects must implement all methods defined in the interface, which allows objects with different specific behaviors to be considered types of the same interface.

interface Vehicle {
    public function start();
    public function stop();
    public function drive();
}

Abstract class

An abstract class is a class that contains at least one unimplemented method. Abstract methods can only be implemented in subclasses of abstract classes, providing specific behaviors for different subclasses.

abstract class Animal {
    abstract public function makeSound();
}

Practical Example: Zoo

Consider the example of a zoo where animals have different behaviors. We can use interfaces and abstract classes to define the public behavior and specific implementation of animals.

Interface

interface AnimalActions {
    public function talk();
    public function walk();
    public function eat();
}

Abstract class

abstract class Animal {
    protected $name;

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

    abstract public function makeSound();
}

Concrete class

class Dog extends Animal implements AnimalActions {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function talk() {
        echo "{$this->name} barks.\n";
    }

    public function walk() {
        echo "{$this->name} walks.\n";
    }

    public function eat() {
        echo "{$this->name} eats dog food.\n";
    }

    public function makeSound() {
        echo "Woof!\n";
    }
}

class Cat extends Animal implements AnimalActions {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function talk() {
        echo "{$this->name} meows.\n";
    }

    public function walk() {
        echo "{$this->name} slinks.\n";
    }

    public function eat() {
        echo "{$this->name} eats cat food.\n";
    }

    public function makeSound() {
        echo "Meow!\n";
    }
}

Using

we can create a zoo class to manage animals:

class Zoo {
    private $animals = [];

    public function addAnimal(AnimalActions $animal) {
        $this->animals[] = $animal;
    }

    public function letAnimalsTalk() {
        foreach ($this->animals as $animal) {
            $animal->talk();
        }
    }
}

In the main script we can create a zoo, add animals, and then make them talk:

$zoo = new Zoo();
$zoo->addAnimal(new Dog('Buddy'));
$zoo->addAnimal(new Cat('Fluffy'));
$zoo->letAnimalsTalk();

This will output:

Buddy barks.
Fluffy meows.

The above is the detailed content of How to implement polymorphism in PHP?. For more information, please follow other related articles on the PHP Chinese website!