Curriculum

PHP Basic

PHP Intro

0/1

PHP Install

0/1

PHP Syntax

0/1

PHP Comments

0/2

PHP Variables

0/4

PHP echo / print

0/3

PHP Data Types

0/7

PHP Strings

0/5

PHP Numbers

0/2

PHP Casting

0/1

PHP Math

0/1

PHP Constants

0/1

PHP Magic Constants

0/1

PHP Operators

0/1

PHP if...Else...Elseif

0/5

PHP switch

0/1

PHP Loops

0/7

PHP Functions

0/6

PHP Arrays

0/11

PHP Superglobals

0/7

PHP RegEx

0/1

PHP Form

0/9

PHP Advanced

0/15

PHP OOP

0/14

MySQL Database

0/14

PHP XML

0/5

PHP Reference

0/276

Text lesson

PHP Inheritance

PHP – What is Inheritance?

Inheritance in OOP occurs when a class derives from another class.

The child class inherits all the public and protected properties and methods from the parent class, and it can also define its own properties and methods.

An inherited class is defined using the extends keyword.

Here’s an example:

Example

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
}
  public function intro() {
    echo “The fruit is {$this->name} and the color is {$this->color}.”;
}
}

// Strawberry is inherited from Fruit
class Strawberry extends Fruit {
  public function message() {
    echo “Am I a fruit or a berry? “;
}
}
$strawberry = new Strawberry(“Strawberry”, “red”);
$strawberry->message();
$strawberry->intro();
?>

Example Explained

The Strawberry class inherits from the Fruit class.

This means that the Strawberry class can access the public $name and $color properties, as well as the __construct() and intro() methods from the Fruit class due to inheritance.

Additionally, the Strawberry class defines its own method: message().

PHP – Inheritance and the Protected Access Modifier

In the previous chapter, we learned that protected properties or methods can be accessed within the class itself and by any classes that inherit from it. What does this mean?

Let’s explore with an example:

Example

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
}
  protected function intro() {
    echo “The fruit is {$this->name} and the color is {$this->color}.”;
}
}

class Strawberry extends Fruit {
  public function message() {
    echo “Am I a fruit or a berry? “;
}
}

// Try to call all three methods from outside class
$strawberry = new Strawberry(“Strawberry”, “red”);  // OK. __construct() is public
$strawberry->message(); // OK. message() is public
$strawberry->intro(); // ERROR. intro() is protected
?>

In the example above we see that if we try to call a protected method (intro()) from outside the class, we will receive an error. public methods will work fine!

Let’s look at another example:

Example

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
  }
  protected function intro() {
    echo “The fruit is {$this->name} and the color is {$this->color}.”;
}
}

class Strawberry extends Fruit {
  public function message() {
    echo “Am I a fruit or a berry? “;
    // Call protected method from within derived class – OK
    $this -> intro();
}
}

$strawberry = new Strawberry(“Strawberry”, “red”); // OK. __construct() is public
$strawberry->message(); // OK. message() is public and it calls intro() (which is protected) from within the derived class
?>

In the example above, everything works correctly because we are calling the protected method (intro()) from within the derived class.

PHP – Overriding Inherited Methods

Inherited methods can be overridden by redefining them (using the same name) in the child class.

In the example below, the __construct() and intro() methods in the Strawberry class will override the __construct() and intro() methods from the Fruit class.

Example

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
}
  public function intro() {
    echo “The fruit is {$this->name} and the color is {$this->color}.”;
}
}

class Strawberry extends Fruit {
  public $weight;
  public function __construct($name, $color, $weight) {
    $this->name = $name;
    $this->color = $color;
    $this->weight = $weight;
}
  public function intro() {
    echo “The fruit is {$this->name}, the color is {$this->color}, and the weight is {$this->weight} gram.”;
}
}

$strawberry = new Strawberry(“Strawberry”, “red”, 50);
$strawberry->intro();
?>

PHP – The final Keyword

The final keyword can be used to prevent a class from being inherited or to stop methods from being overridden.

The following example demonstrates how to prevent class inheritance:

Example

<?php
final class Fruit {
// some code
}

// will result in error
class Strawberry extends Fruit {
// some code
}
?>

The following example illustrates how to prevent method overriding:

Example

<?php
class Fruit {
  final public function intro() {
    // some code
}
}

class Strawberry extends Fruit {
  // will result in error
  public function intro() {
    // some code
}
}
?>