Overriding in PHP

In PHP, "overriding" is a fundamental concept in object-oriented programming (OOP), particularly in the context of inheritance. When working with object-oriented code, you often create classes that represent real-world entities or concepts. Inheritance allows you to create a hierarchy of classes, where a child class can inherit properties and methods from a parent class. One powerful feature of inheritance is method overriding, which enables you to customize the behavior of inherited methods in the child class.

Understanding Method Overriding

Method overriding in PHP involves providing a specific implementation of a method in a child class that differs from the implementation in the parent class. This means that when you call the overridden method on an object of the child class, the child class's implementation is executed instead of the parent class's. This behavior allows you to create more specialized and flexible object-oriented code.

Let's delve deeper into the concept of method overriding with a practical example:

class Animal 
{
    public function speak(): void 
    {
        echo "Animal speaks!";
    }
}

class Dog extends Animal 
{
    public function speak(): void
    {
        echo "Woof!";
    }
}

$animal = new Animal();
$dog = new Dog();
$animal->speak(); // Output: "Animal speaks!"
$dog->speak();    // Output: "Woof!"        

In this example:

1. We have a parent class Animal with a method speak().

2. We create a child class Dog that extends Animal.

3. In the Dog class, we override the speak() method to provide a different implementation.

4. When we create instances of both classes and call the speak() method on each, you can see that the overridden method in the child class is called for the Dog object, whereas the method in the parent class is called for the Animal object.

Key Points to Remember

1. Method Signature: When overriding a method in a child class, it must have the same name, parameter list, and access modifier (or a less restrictive one) as the method in the parent class. This ensures that it is a valid override.

2. No 'override' Keyword: Unlike some other programming languages, PHP does not use an explicit "override" keyword. Instead, PHP recognizes a method in a child class as an override if it has the same name and parameters as the method in the parent class.

?? BUT in PHP 8.3

The #[Override] attribute is a new feature in PHP 8.3 that can be used to mark a method as overriding a method in a parent class. This can be useful for static analysis tools, which can use the #[Override] attribute to check for errors in code that overrides methods.

The #[Override] attribute is not required, but it is a good practice to use it when overriding methods. This helps to make your code more readable and maintainable, and it can also help to prevent errors.

class Animal 
{
    public function speak(): void 
    {
        echo "Animal speaks!";
    }
}

class Dog extends Animal 
{
    #[Override]
    public function speak(): void
    {
        echo "Woof!";
    }
}        

Enhancing with parent::

While method overriding is powerful, there are scenarios where you want to extend the behavior of the parent class's method while incorporating additional functionality in the child class. PHP provides the parent:: keyword for this purpose. It allows you to call a method from the parent class within the child class, even if that method has been overridden in the child class.

Here's an example:

class Animal 
{
    public function speak(): void 
    {
        echo "Animal speaks!";
    }

}

class Dog extends Animal 
{
    #[Override]
    public function speak(): void
    {
        parent::speak(); // Calling the speak() method from the parent class
        echo "Woof!";
    }
}

$dog = new Dog();
$dog->speak();        

In this example:

1. We have a parent class Animal with a speak() method.

2. We create a child class Dog that extends Animal. In the speak() method of the Dog class, we use parent::speak(); to call the speak() method from the parent class.

3. When we create an instance of the Dog class and call its speak() method, it first calls the speak() method from the parent class using parent::speak();, and then it adds the "Woof!" message.

This powerful combination of method overriding and parent:: allows you to build upon the functionality of the parent class's method while customizing it in the child classes. It promotes code reusability and flexibility in your object-oriented PHP applications.

In conclusion, method overriding is a core concept in PHP's object-oriented programming paradigm, enabling you to create more dynamic and specialized classes by customizing inherited methods. By understanding and effectively using method overriding and the parent:: keyword, you can create well-structured and extensible PHP code.