Class Inheritance Basics

Class Inheritance is a way to extend a class. The new class (child class) builds or overwrites logic from the parent class (super class).

The syntax for class extension is:

class ChildClass extends ParentClass { // code }

Overwriting methods:

Overwritten method is a method that has been inherited from the parent but it's logic is changed in the child.

Syntax for overwriting function:

class ParentClass { function funcName(args) { // code } } class ChildClass extends ParentClass { function funcName(args) { // overwriting function } }

Let's have a base class Vehicle and child classes - Car, Scooter, Bicycle. We'll set a simplified formula for the insurance cost.

<?php class Vehicle { public function getInsuranceCost($months) { return 0; } } // Scooter inherits Vehicle. class Scooter extends Vehicle { // overwriting method public function getInsuranceCost($months) { return $months * 15; } } // Car inherits Vehicle. class Car extends Vehicle { // overwriting method public function getInsuranceCost($months) { return $months * 25; } } // Bicycle inherits Vehicle. class Bicycle extends Vehicle { // the class uses getInsuranceCost() // inherited from Vehicle. } $scooter = new Scooter(); echo "Scooter Year Insurance: " . $scooter->getInsuranceCost(12) . " $\n"; $car = new Car(); echo "Car Year Insurance: " . $car->getInsuranceCost(12) . " $\n"; $bike = new Bicycle(); echo "Bicycle Year Insurance: " . $bike->getInsuranceCost(12) . " $\n";

Output:

Scooter Year Insurance: 180 $ Car Year Insurance: 300 $ Bicycle Year Insurance: 0 $

Explanation:

• At line 11 the class Scooter inherits the Vehicle class. And at lines 14 to 17 the function getInsuranceCost is overwritten.
• At line 21 the class Car extends the Vehicle class. The Car class overwrites getInsuranceCost function at lines 24 - 27.
• At line 31 the Bicycle class extends Vehicle. It doesn't overwrite the getInsuranceCost method. When called (line 47) the code from the base class is executed.

Extending functions and constructors:

Let's have a base class Vehicle and child class Car. The child class will add one more member and also extend a constructor and a function called representation.

<?php class Vehicle { protected $brand; protected $model; public function __construct($brandValue, $modelValue) { $this->brand = $brandValue; $this->model = $modelValue; echo "Vehicle constructor\n"; } public function representation() { echo "Brand: " . $this->brand . "\n"; } } class Car extends Vehicle { private $horsePowers; public function __construct($brandValue, $modelValue, $horsePowersValue) { parent::__construct($brandValue, $modelValue); echo "Car constructor \n"; $this->horsePowers = $horsePowersValue; } public function representation() { parent::representation(); echo "Model: " . $this->model . "\n"; echo "Horse Powers: " . $this->horsePowers . "\n"; } } $sampleBicycle = new Vehicle("Merida ", "ONE-FORTY 800"); $sampleBicycle->representation(); echo "--------------------\n"; $fordCar = new Car("Ford", "Fiesta", 80); $fordCar->representation(); echo "--------------------\n"; $toyotaCar = new Car("Toyota", "Corolla", 100); $toyotaCar->representation();

Output:

Vehicle constructor Brand: Merida -------------------- Vehicle constructor Car constructor Brand: Ford Model: Fiesta Horse Powers: 80 -------------------- Vehicle constructor Car constructor Brand: Toyota Model: Corolla Horse Powers: 100

Explanation:

• At lines 4 and 5 instead of private the members are defined as protected. That's because we want to extend the class and inherit it's members. More details about it later in the lesson.
• At line 21 the class Car inherits Vehicle.
• The Car class has 3 members - horsePowers defined at line 23 and also brand and model (lines 4 and 5) due to the class extension.
• The Car class constructor calls the Vehicle constructor at line 27 via the parent keyword. When car object is created (lines 46 and 50) the code from the parent's class constructor (lines 9 - 12) executes first and afterwards the code from child's constructor (lines 31 - 33).
• At line 35 the representation function of the parent class is called. When representation function is called for a Vehicle object at line 43, only the brand is printed.
• When representation function is called for a Car object at lines 47 and 51, all 3 members (make, model, horsePowers) are printed).

Private vs protected members

Both private and protected members can be accessed or modified only in a class body.

Private Members can be accessed or modified only in one class - the one they are defined in.

Protected members can be accessed or modified in the class they are defined in and the classes that extend it.

Let's look at the example:

<?php class Vehicle { protected $brand = 'Default Brand'; private $model = 'Default model'; } class Car extends Vehicle {} $vehicle = new Vehicle(); $car = new Car(); $vehicle->randomProperty = 'random value'; // $vehicle->brand = 'Ford'; $car->model = 'Fiesta'; // $car->brand = 'Ford';

• Due to the extension class Car has 1 members - brand.
• If line 14 or 17 is uncommented the code won't compile since a private or protected member cannot be accessed outside the class.
• Public or undefined property (like randomProperty in this case) can be accessed outside the class body.