PHP classes: the basics of object-oriented programming

What is the relationship between PHP classes and PHP objects?¶

Objects are instances of a class. Once you instantiate a class, you get a concrete object capable of accessing the properties and methods defined in the class. To create the objects of a class, you should use the keyword “ new »:

class Animal {
  // Properties
  public $name;
  public $color;

  // Methods
  function set_name($name) {
    $this->name = $name;
  }
  function get_name() {
    return $this->name;
  }
}

$dog = new Animal();
$cat = new Animal();
$dog->set_name('Tom');
$cat->set_name('Mickey');

echo $dog->get_name();
echo "<br>";
echo $cat->get_name();

In this case, “dog” and “cat” are two instances of the “Animal” class, each with its own name.

PHP classes can also be inherited, which means you are free to use an existing class in order to define a new one; it then inherits the properties and methods of the class on which it is based. You can reuse these functions and improve them. The objects of this new class are also instances of the base class, and can therefore use its methods.

class Mammal extends Animal {
function breathesAir() {
      echo "inhale";
    }
}

$horse = new Mammal;
$horse->setName("Louis");

Using the keyword “ extends “, the class “Mammal” (mammal) therefore inherits all the properties and methods of its higher class, “Animal”. We are then able to add a new function to the “Mammal” class, but also to access those it inherited.

Application examples of PHP classes¶

PHP classes offer many application possibilities. Below are some practical examples.

PHP instanceof¶

In PHP, the operator instanceof allows you to check if an object belongs to a specific class or a class inherited from it.

Below is a simple example:

class Animal {
    public function speak() {
        echo "sound";
    }
}

class Dog extends Animal {
    public function speak() {
        echo "bark";
    }
}

$animal = new Dog();

if ($animal instanceof Animal) {
    $animal->speak(); // Output: "bark"
}

We start by using the “instanceof” operator to check if $animal is an instance of the PHP class “Animal” or one of its inherited classes. Given that$animal is an instance of the “Dog” class (which inherits from “Animal”), the condition is met and the code of the “if” block is therefore executed.

The operator instanceof may be useful to you if you want to check that you can access certain methods or properties without exposing yourself to errors (if the object does not have the expected class).

PHP Classes and PHP Arrays¶

You can store classes in PHP arrays to create complex data structures.

class Product {
    public $name;
    public $price;

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

$products = [
    new Product("Laptop", 800),
    new Product("Smartphone", 400),
    new Product("Tablet", 300)
];

foreach ($products as $product) {
    echo "Product: " . $product->name . ", Price: $" . $product->price . "<br>";
}

In this example, we define the “Product” class to represent different products, which are then stored in the “products” table. We can then iterate through the array using PHP loops, like foreach constructionto display the name and price of the products.

PHP Class Constructor¶

The constructor corresponds to a special method within a PHP class. This is called automatically each time an object of this class is created. The purpose of a constructor is to format the initial state of an object or to perform other preparatory tasks necessary for the proper functioning of said object.

class Dog {
    private $name;
    private $color;

    // Constructor
    public function __construct($name, $color) {
        $this->name = $name;
        $this->color = $color;
    }

    public function sayHello() {
        return "Hello, my name is {$this->name} and my color is {$this->color}.";
    }
}

$dog = new Dog("Tom", "brown");

echo $dog->sayHello(); // Output: "Hello, my name is Tom and my color is brown."