PHP OOP Fundamentals - Inheritance in PHP

Inheritance is one of the key principles of Object-Oriented Programming (OOP) in PHP. It allows you to create a new class based on an existing class, promoting code reuse and reducing redundancy. By using inheritance, a child class can inherit the properties and methods of a parent class while also being able to add or override them. This makes your code more modular, maintainable, and scalable.

In this blog, we will explore the concept of inheritance in PHP using the latest syntax and features available in PHP 8.x. Let’s break down the fundamentals of inheritance, how it works, and how to use it effectively.

What is Inheritance in PHP?

In PHP, inheritance allows one class (called the child or subclass) to inherit properties and methods from another class (called the parent or superclass). This means that you can reuse code from the parent class without duplicating it, and you can also extend or override the inherited functionality to meet the needs of the subclass.

Key Points:

Parent Class: The class from which properties and methods are inherited.
Child Class: The class that inherits properties and methods from the parent class.
A child class can extend only one parent class.
Methods and properties that are declared as protected or public in the parent class can be accessed by the child class, but private members are not accessible.

Syntax of Inheritance in PHP

Inheritance is implemented using the extends keyword in PHP. Here's a basic example of inheritance:

class Animal
{
    protected string $name;

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

    public function eat(): void
    {
        echo $this->name . " is eating.\n";
    }
}

class Dog extends Animal
{
    public function bark(): void
    {
        echo $this->name . " is barking.\n";
    }
}

In the example above:

Dog is the child class that extends the Animal class.
The Dog class inherits the name property and the eat() method from Animal, while also adding its own bark() method.

You can now create an instance of Dog and call both the inherited eat() method and the new bark() method:

$dog = new Dog("Buddy");
$dog->eat();  // Output: Buddy is eating.
$dog->bark(); // Output: Buddy is barking.

Access Modifiers in Inheritance

In PHP, access modifiers play a key role in inheritance:

Public: Public properties and methods are accessible from both inside and outside the class, including child classes.
Protected: Protected members are accessible within the class itself and in its child classes, but not from outside.
Private: Private members are only accessible within the class where they are defined and not in child classes.

Let’s modify the above example to demonstrate the behavior of access modifiers:

class Animal
{
    private string $species;
    protected string $name;

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

    protected function getSpecies(): string
    {
        return $this->species;
    }

    public function describe(): void
    {
        echo $this->name . " is a " . $this->getSpecies() . ".\n";
    }
}

class Dog extends Animal
{
    public function bark(): void
    {
        echo $this->name . " is barking.\n";
        // Note: Cannot access $species directly as it is private.
    }
}

In this case:

The $species property is private, so it is not accessible in the Dog class.
The $name property is protected, so it can be accessed within the Dog class.

Overriding Methods in PHP

Child classes can override methods from the parent class to provide a specific implementation for that method. This is one of the key features of inheritance and helps in customizing behavior while retaining a common structure.

Let’s look at how to override a method in PHP:

class Animal
{
    protected string $name;

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

    public function makeSound(): void
    {
        echo $this->name . " makes a sound.\n";
    }
}

class Dog extends Animal
{
    public function makeSound(): void
    {
        echo $this->name . " barks.\n";
    }
}

Here, the Dog class overrides the makeSound() method from the Animal class to specify that a dog "barks" rather than making a generic sound.

$animal = new Animal("Generic Animal");
$animal->makeSound();  // Output: Generic Animal makes a sound.

$dog = new Dog("Buddy");
$dog->makeSound();     // Output: Buddy barks.

Calling the Parent’s Method

When overriding a method in a child class, you might still want to use the logic from the parent class's method. This can be done using the parent:: keyword.

Example:

class Animal
{
    protected string $name;

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

    public function makeSound(): void
    {
        echo $this->name . " makes a sound.\n";
    }
}

class Dog extends Animal
{
    public function makeSound(): void
    {
        parent::makeSound();  // Calls the parent class's makeSound() method.
        echo $this->name . " barks.\n";
    }
}

$dog = new Dog("Buddy");
$dog->makeSound();

// Output:
// Buddy makes a sound.
// Buddy barks.

In this example, parent::makeSound() calls the makeSound() method from the Animal class before adding the custom behavior in the Dog class.

Constructors and Inheritance

In PHP, when a child class is instantiated, it does not automatically call the constructor of the parent class. If the parent class has a constructor, you need to call it explicitly using parent::__construct() in the child class's constructor.

Let’s update the previous example to include constructor inheritance:

class Animal
{
    protected string $name;

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

class Dog extends Animal
{
    public function __construct(string $name)
    {
        parent::__construct($name);  // Call the parent constructor
    }

    public function bark(): void
    {
        echo $this->name . " is barking.\n";
    }
}

By calling parent::__construct($name) in the Dog class, we ensure that the parent class’s constructor is invoked when a Dog object is created.

Final Classes and Methods

In some cases, you may want to prevent a class from being inherited or a method from being overridden. PHP provides the final keyword for this purpose.

A final class cannot be extended.
A final method cannot be overridden by subclasses.

final class Cat
{
    public function meow(): void
    {
        echo "Meow!";
    }
}

// This will cause an error because Cat is final and cannot be extended.
// class Lion extends Cat {}

class Dog extends Animal
{
    final public function bark(): void
    {
        echo $this->name . " is barking.\n";
    }
}

// This will cause an error because bark() is final and cannot be overridden.
// class SmallDog extends Dog
// {
//     public function bark(): void {}
// }

Benefits of Inheritance in PHP

Code Reusability: By inheriting common methods and properties from a parent class, you avoid duplicating code, which makes your codebase cleaner and more maintainable.
Extensibility: Child classes can extend the functionality of a parent class, enabling you to add or override behavior without modifying the parent class directly.
Maintainability: Changes in the parent class can be reflected across all its child classes, making it easier to update and maintain large systems.
Organization: Inheritance helps in organizing code logically. For example, you can have a base class for animals and extend specific animal types (dog, cat, etc.) from that base.

Conclusion

Inheritance is a powerful tool in PHP’s OOP model, enabling you to write modular, reusable, and maintainable code. It allows child classes to inherit properties and methods from parent classes while also giving the flexibility to override or extend them. Whether you are building a complex system or a small-scale application, leveraging inheritance can significantly improve your code's organization and efficiency.

By using the latest PHP 8.x features such as strict types, improved constructor inheritance, and visibility modifiers, you can take full advantage of the OOP paradigm and build robust and modern PHP applications.