Programmation web orientée objet et introduction à Laravel

3.1. Classes, Objets, Propriétés et Méthodes

Une **classe** est un plan de construction. Un **objet** est une instance de cette classe. Les **propriétés** sont les variables de la classe (ses données), et les **méthodes** sont ses fonctions (ses actions).

3.2. Instanciation et le Rôle du Constructeur

L'instanciation est l'acte de créer un objet concret (une instance) à partir d'une classe en utilisant le mot-clé new. Pour s'assurer qu'un objet est créé dans un état valide et prêt à l'emploi, PHP appelle automatiquement une méthode spéciale au moment de l'instanciation : le constructeur (__construct).

Le constructeur est idéal pour initialiser les propriétés d'un objet avec les valeurs nécessaires à son fonctionnement. Les arguments passés après le nom de la classe lors de l'appel `new` sont directement transmis au constructeur.

3.3. Encapsulation (Visibilité)

L'encapsulation consiste à protéger l'état interne d'un objet. On utilise des mots-clés de visibilité pour contrôler l'accès aux propriétés et méthodes :

• public : Accessible de partout.
• protected : Accessible uniquement par la classe elle-même et ses classes enfants.
• private : Accessible uniquement par la classe elle-même.

3.4. Héritage

L'héritage permet à une classe (enfant) d'hériter des propriétés et méthodes d'une autre classe (parente). Cela favorise la réutilisation du code en créant des spécialisations.

3.5. Polymorphisme : Un Comportement, Plusieurs Formes

Le polymorphisme (du grec "plusieurs formes") est une conséquence directe de l'héritage. Il permet de manipuler des objets de classes différentes comme s'ils étaient du même type (le type de la classe parente). Le programme détermine alors au moment de l'exécution quelle méthode spécifique appeler (celle du parent ou celle de l'enfant). C'est ce qui permet d'écrire du code générique et flexible, capable de traiter une famille d'objets sans connaître les détails de chaque classe.

3.6. Surcharge de Méthode (Overloading) : L'Approche de PHP

Contrairement à des langages comme Java ou C#, PHP ne supporte pas la surcharge de méthode traditionnelle, qui consiste à définir plusieurs méthodes avec le même nom mais des signatures (nombre ou type de paramètres) différentes. Déclarer deux fois la même fonction dans une classe PHP générera une erreur fatale.

Cependant, PHP permet d'obtenir un comportement très similaire en créant une méthode unique et flexible qui réagit différemment en fonction des arguments qu'elle reçoit. On y parvient le plus souvent en utilisant des paramètres optionnels avec des valeurs par défaut.

3.7. Redéfinition de Méthode (Overriding) : Spécialiser le Comportement

Alors que la surcharge (simulée en PHP) concerne des méthodes de même nom au sein d'une même classe, la redéfinition (Overriding) est un concept fondamental de l'héritage. Elle permet à une classe enfant de fournir une implémentation spécifique pour une méthode qui est déjà définie dans sa classe parente. La signature de la méthode (nom, nombre et type de paramètres) doit rester compatible.

C'est un pilier du polymorphisme, car cela permet à un objet enfant de réagir différemment au même appel de méthode que son parent, adaptant ainsi son comportement.

3.8. Membres Statiques : Propriétés et Méthodes de Classe

Jusqu'à présent, toutes les propriétés et méthodes que nous avons vues appartenaient à une instance d'objet (un objet créé avec `new`). Le mot-clé `static` permet de déclarer des membres qui appartiennent à la classe elle-même, et non à une de ses instances. Ils sont accessibles directement via le nom de la classe, sans avoir besoin de créer un objet.

• Propriétés Statiques : Elles sont partagées par toutes les instances d'une classe. Si une instance modifie la valeur, la modification est visible par toutes les autres. Elles sont utiles pour des compteurs, des configurations, etc.
• Méthodes Statiques : Elles peuvent être appelées sans créer d'objet. Elles sont souvent utilisées pour des fonctions utilitaires (ex: conversions, validateurs) qui n'ont pas besoin de l'état d'un objet pour fonctionner. Attention : une méthode statique ne peut pas utiliser la pseudo-variable $this, car elle n'est pas liée à une instance.

<?php
class CompteurUtilisateurs
{
    // Cette propriété appartient à la CLASSE, il n'y en a qu'une seule copie.
    public static int $nombreTotal = 0;

    public function __construct()
    {
        // On accède à la propriété statique avec self::
        self::$nombreTotal++;
    }

    // Cette méthode peut être appelée sans créer d'objet.
    public static function afficherTotal(): void
    {
        echo "Nombre total d'utilisateurs créés : " . self::$nombreTotal;
    }
}

// On peut appeler la méthode statique SANS instance.
CompteurUtilisateurs::afficherTotal(); // Affiche 0
echo "\n";

$user1 = new CompteurUtilisateurs();
$user2 = new CompteurUtilisateurs();

// La propriété statique a été modifiée par les instances.
CompteurUtilisateurs::afficherTotal(); // Affiche 2

4.1. Classes Abstraites et Interfaces

Ces deux concepts permettent de définir des "contrats" que d'autres classes doivent respecter.
• Une **classe abstraite** (`abstract`) est un modèle partiel de classe qui ne peut pas être instancié directement.

<?php
// On définit une classe abstraite avec le mot-clé 'abstract'.
// Elle sert de "modèle" ou de "plan" pour d'autres classes.
abstract class Vehicule
{
    protected string $marque;

    // Une classe abstraite peut avoir un constructeur et des méthodes déjà implémentées.
    public function __construct(string $marque)
    {
        $this->marque = $marque;
    }

    // Méthode concrète (avec du code) que toutes les classes enfants hériteront.
    public function getMarque(): string
    {
        return "Ce véhicule est de la marque " . $this->marque;
    }

    // On déclare une méthode abstraite. Elle n'a pas de corps (pas de { ... }).
    // Toute classe qui héritera de Vehicule SERA OBLIGÉE de définir cette méthode.
    abstract public function getNombreDeRoues(): int;
}

// La classe Voiture hérite de Vehicule.
class Voiture extends Vehicule
{
    // On DOIT implémenter la méthode abstraite du parent.
    public function getNombreDeRoues(): int
    {
        return 4;
    }
}

// La classe Moto hérite aussi de Vehicule.
class Moto extends Vehicule
{
    // Elle doit aussi implémenter la méthode avec sa propre logique.
    public function getNombreDeRoues(): int
    {
        return 2;
    }
}

// On ne peut pas instancier directement une classe abstraite.
// $vehicule = new Vehicule("Générique"); // ERREUR FATALE !

// On instancie les classes enfants, qui sont concrètes.
$maVoiture = new Voiture('Renault');
echo $maVoiture->getMarque() . " et a " . $maVoiture->getNombreDeRoues() . " roues.\n";

$maMoto = new Moto('Yamaha');
echo $maMoto->getMarque() . " et a " . $maMoto->getNombreDeRoues() . " roues.\n";

4.2. Les Traits : Réutiliser du Code Horizontalement

PHP ne supporte que l'héritage simple (une classe ne peut hériter que d'une seule autre classe). Pour contourner cette limite et partager du code entre des classes non liées, PHP propose les Traits. Un trait est un regroupement de méthodes (et de propriétés) que l'on peut "importer" dans une classe avec le mot-clé use.

C'est un mécanisme de réutilisation de code "horizontal", contrairement à l'héritage qui est "vertical". Par exemple, un trait `LoggerTrait` peut ajouter une capacité de logging à n'importe quelle classe, qu'il s'agisse d'un `UserService` ou d'un `OrderProcessor`.

4.3. Le Singleton : Garantir une Instance Unique

Le pattern Singleton est un modèle de conception qui restreint l'instanciation d'une classe à un seul objet. Il est utile pour gérer des ressources partagées, comme une connexion à la base de données ou un objet de configuration, afin d'éviter la création d'instances multiples, coûteuses et potentiellement conflictuelles.

Son implémentation repose sur trois piliers : un constructeur privé pour empêcher l'instanciation externe, une propriété statique privée pour stocker l'unique instance, et une méthode statique publique (souvent `getInstance`) pour y accéder.

4.4. La Factory : Centraliser la Création d'Objets

Le pattern Factory (ou "Fabrique") propose de déléguer la création d'objets à une classe ou une méthode dédiée. Son but est de **découpler** le code client (qui a besoin d'un objet) de la logique de création de cet objet. C'est extrêmement puissant : si la manière de créer un objet doit changer, on ne modifie que la factory, sans toucher au reste de l'application.

Ce pattern est souvent utilisé pour instancier des classes différentes en fonction d'un paramètre, comme nous le verrons dans l'exercice sur les produits.