PHP OOP Inheritance

Inheritance is a fundamental concept in Object-Oriented Programming (OOP) that allows developers to create new objects from existing ones, inheriting all its properties and methods. In PHP, inheritance is implemented using the extends keyword. In this article, we'll explore PHP OOP inheritance in depth and understand how it can be used to simplify your code and create more maintainable applications.

What is Inheritance?

Inheritance is a feature of OOP that allows developers to create new classes based on existing ones. The newly created class inherits all the properties and methods of the original class, also called the base or parent class. Inheritance is used to create a hierarchy of classes, where subclasses inherit the properties and methods of the parent class, and can also add new properties and methods of their own.

Benefits of Inheritance

There are several benefits of inheritance in PHP OOP, including:

  • Reusability: Reuse the properties and methods of existing classes, avoiding the need to write new code for similar objects.
  • Code Maintainability: Makes code more organized and easier to maintain by reducing code duplication and promoting code reuse.
  • Polymorphism: Ability to use objects of different classes interchangeably, through inheritance.
  • Abstraction: Encapsulation of properties and methods in a parent class, hiding the implementation details and making it easier to use subclasses.

PHP OOP Inheritance Syntax

The syntax of inheritance in PHP is simple. To create a subclass, you use the extends keyword, followed by the name of the parent class. For example:

class ChildClass extends ParentClass {
    // Class body
}

The subclass ChildClass inherits all the properties and methods of the parent class ParentClass. To access the properties and methods of the parent class, you use the parent keyword.

Overriding Parent Methods

Inheritance allows subclasses to override parent class methods, which means they can provide a new implementation of the method. To override a parent class method, you simply declare a new method with the same name in the subclass. For example:

class ParentClass {
    public function displayMessage() {
        echo "Hello from ParentClass";
    }
}

class ChildClass extends ParentClass {
    public function displayMessage() {
        echo "Hello from ChildClass";
    }
}

In this example, the ChildClass overrides the displayMessage method of the ParentClass. To access the parent class method, you can use the parent keyword. For example:

class ChildClass extends ParentClass {
    public function displayMessage() {
        parent::displayMessage();
        echo "Hello from ChildClass";
    }
}

PHP OOP Inheritance Example

Let's look at a real-world example of how inheritance can be used in PHP OOP. Consider a scenario where you have a Vehicle class with properties such as make, model, and year. You can then create a Car class that inherits from the Vehicle class, adding a new property fuelType.

<?php

class Vehicle
{
    public $make;
    public $model;
    public $year;

    public function displayDetails()
    {
        echo "Make: " . $this->make . "\n";
        echo "Model: " . $this->model . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

class Car extends Vehicle
{
    public $fuelType;
    public function displayDetails()
    {
        parent::displayDetails();
        echo "Fuel Type: " . $this->fuelType . "\n";
    }
}

In this example, the `Car` class inherits the properties and methods of the `Vehicle` class, but also adds a new property `fuelType`. The `displayDetails` method of the `Car` class also overrides the method of the same name in the `Vehicle` class, adding the output of the `fuelType` property.

Conclusion

Inheritance is a fundamental concept in PHP OOP, allowing developers to create new objects from existing ones, inheriting all their properties and methods. Inheritance helps promote code reuse, maintainability, and abstraction, making it an essential tool for developing PHP applications. In this article, we explored PHP OOP inheritance in detail, including its syntax, benefits, and an example of how it can be used in real-world applications.


Do you find this helpful?