OOP Basics: Inheritance

Inheritance is one of the most important pillars of object-oriented programming. It allows us to create a new class that automatically inherits all public and protected properties and methods of an existing class. In PHP, we achieve this magic using the extends keyword.

With this concept, we create a natural hierarchy between classes, which in programming is described as a Parent → Child or Superclass → Subclass relationship. Imagine the following real-world example:

"Vehicle" Class (Parent): Is a general definition that has properties like $brand and $speed, and a move() method.
"Car" Class (Child): Using extends Vehicle, it automatically inherits all these properties, and in addition, we can add specific things that a general vehicle does not have (e.g., the $doorsCount property or the openTrunk() method).

EXAMPLE

[file:Basic Usage and extends]
<?php
// Superclass (Parent)
class Vehicle {
    public $brand;
    public $speed;

public function __construct($brand, $speed) {
        $this->brand = $brand;
        $this->speed = $speed;
    }

public function move() {
        return "The vehicle {$this->brand} is moving at a speed of {$this->speed} km/h.<br>";
    }
}

// Subclass (Child) - inherits everything from Vehicle
class Car extends Vehicle {
    public $doorsCount;

public function __construct($brand, $speed, $doorsCount) {
        // Using parent::__construct we call and execute the code from the superclass
        parent::__construct($brand, $speed);
        $this->doorsCount = $doorsCount;
    }

public function openTrunk() {
        return "The trunk on the car {$this->brand} (number of doors: {$this->doorsCount}) is open.";
    }
}

// Creating an object from the derived Car class
$myCar = new Car("Renault", 130, 5);

echo $myCar->move(); // Inherited from the Vehicle class
echo $myCar->openTrunk(); // Own method of the Car class
?>

[file:Method Overriding]
<?php
// Sometimes we want a subclass to execute the same method differently.
class BaseDriver {
    public function drive() {
        return "I drive according to the regulations.";
    }
}

class RacingDriver extends BaseDriver {
    public function drive() {
        // We override the superclass method with new logic
        return "I drive fast on the racetrack!";
    }
}

$f1 = new RacingDriver();
echo $f1->drive(); 
?>

[file:Trait]
<?php
// Trait for three-phase charging
trait ThreePhaseCharging {
    public function plugIn400V() {
        return "Charging on 3 phases (11kW). The battery will be full in 5 hours.";
    }
}

class Vehicle {
    public $brand;
    public function __construct($b) { $this->brand = $b; }
}

class ElectricCar extends Vehicle {
    use ThreePhaseCharging;
}

$myCar = new ElectricCar("Tesla");
echo "Vehicle: " . $myCar->brand . "<br>";
echo $myCar->plugIn400V();
?>

RESULT

The result will be displayed here...

Why is Inheritance Such a Powerful Tool?

The main goal of inheritance is to drastically reduce code duplication in your projects (strictly following the DRY principle). Instead of writing identical functions for starting the engine or driving for a Car, a Motorcycle, and a Truck, you write this logic only once in the parent Vehicle class. All other subclasses then simply use it or adapt (override) it as needed.

By using inheritance, your applications become extremely modular, easier to maintain, and ready for quick additions of new, more advanced functionalities without interfering with already working code.