PHP classes : des éléments constitutifs de la programmation orientée objet

Les PHP classes permettent d’organiser le code en modules logiques indépendants, chacun d’eux possédant des propriétés et méthodes qui lui sont propres. Vous pourrez ainsi les réutiliser, et mieux gérer vos gros projets.

PHP classes : de quoi s’agit-il ?

Les classes PHP sont comparables à des modèles ou à des plans de construction utilisés pour créer des objets. Une classe permet de définir les propriétés (variables ou attributs) et les méthodes (fonctions) dont un objet va disposer. Ces classes constituent un élément essentiel de la programmation orientée objet. Elles peuvent, par exemple, être combinées à d’autres fonctions PHP. Vous pouvez aussi créer des classes vous permettant d’utiliser PHP pour récupérer des informations dans une base de données MySQL.

Définition des PHP classes

En PHP, pour définir une classe, il convient d’utiliser le mot-clé « class » suivi du nom de celle-ci et d’accolades. Entre ces accolades, vous pouvez alors renseigner les propriétés et les méthodes de votre classe.

class Name {
    // php class example properties and methods
}

Vous trouverez ci-dessous un exemple concret :

class Animal {
    // Properties
    public $name;
    public $color;
    // Methods
    function set_name($name) {
        $this->name = $name;
    }
    function get_name() {
        return $this->name;
    }
}

La classe « Animal » est accompagnée de deux propriétés, « name » (nom) et « color » (couleur), mais aussi de deux méthodes : l’une pour définir le nom (« set_name ») et l’autre pour le récupérer (« get_name »).

Quel lien existe-t-il entre les classes PHP et les objets PHP ?

Les objets sont des instances d’une classe. Dès lors que vous instanciez une classe, vous récupérez un objet concret capable d’accéder aux propriétés et aux méthodes définies dans la classe. Pour créer les objets d’une classe, il convient d’utiliser le mot-clé « 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();

Dans ce cas précis, « dog » (chien) et « cat » (chat) sont deux instances de la classe « Animal », chacune ayant son propre nom.

Les classes PHP peuvent aussi être héritées, ce qui veut dire que vous êtes libre de vous servir d’une classe existante afin d’en définir une nouvelle ; celle-ci hérite alors des propriétés et des méthodes de la classe sur laquelle elle se base. Vous pouvez ainsi réutiliser ces fonctions et les améliorer. Les objets de cette nouvelle classe sont eux aussi des instances de la classe de base, et peuvent donc utiliser ses méthodes.

class Mammal extends Animal {
function breathesAir() {
      echo "inhale";
    }
}
$horse = new Mammal;
$horse->setName("Louis");

Grâce au mot-clé « extends », la classe « Mammal » (mammifère) hérite donc de l’ensemble des propriétés et méthodes de sa classe supérieure, « Animal ». Nous sommes alors en mesure d’ajouter une nouvelle fonction à la classe « Mammal », mais aussi d’accéder à celles dont elle a hérité.

Exemples d’application des PHP classes

Les classes PHP offrent de nombreuses possibilités d’application. Vous trouverez ci-dessous quelques exemples pratiques.

PHP instanceof

En PHP, l’opérateur instanceof permet de vérifier si un objet appartient à une classe spécifique ou à une classe héritée par rapport à celle-ci.

Vous trouverez ci-dessous un exemple simple :

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"
}

Nous commençons par utiliser l’opérateur « instanceof » pour vérifier si $animal est une instance de la classe PHP « Animal » ou de l’une de ses classes héritées. Étant donné qu’$animal est une instance de la classe « Dog » (qui pour sa part hérite d’« Animal »), la condition est remplie et le code du bloc « if » est donc exécuté.

L’opérateur instanceof peut vous être utile si vous voulez vérifier que vous pouvez bien accéder à certaines méthodes ou propriétés sans vous exposer à des erreurs (si l’objet n’a pas la classe attendue).

Classes PHP et tableaux PHP

Vous pouvez stocker les classes dans des tableaux PHP pour créer des structures de données complexes.

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>";
}

Dans cet exemple, nous définissons la classe « Product » (produit) pour représenter différents produits, ensuite stockés dans le tableau « products ». Nous pouvons alors parcourir le tableau à l’aide de boucles PHP, comme la construction foreach, pour afficher le nom et le prix des produits.

PHP Class Constructor

Le constructeur correspond à une méthode spéciale au sein d’une classe PHP. Celle-ci est appelée automatiquement chaque fois qu’un objet de cette classe est créé. Un constructeur a pour but de formater l’état initial d’un objet ou d’effectuer d’autres tâches préparatoires nécessaires au bon fonctionnement dudit objet.

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."