Classes et objets en PHP

De la théorie à la syntaxe PHP

Dans le cours « La POO expliquée simplement », tu as vu les idées : un objet regroupe des propriétés (données) et des méthodes (actions), et une classe est le moule. Ici, on traduit tout ça en PHP concret, et tu l'exécutes directement.

Petite note rassurante : la syntaxe objet de PHP ressemble beaucoup à celle de Java, C# ou JavaScript. Apprendre ici, c'est apprendre presque partout.

Déclarer une classe

Le mot-clé class, des propriétés (typées, c'est mieux) et des méthodes. À l'intérieur, $this désigne l'objet courant.

class Compte {
    public string $titulaire;     // une propriété typée
    public float $solde = 0;       // avec une valeur par défaut

    public function deposer(float $montant): void {
        $this->solde += $montant;   // $this = CET objet
    }
}

Note le -> (flèche) : en PHP, on accède aux propriétés et méthodes d'un objet avec $objet->propriete et $objet->methode(), pas avec un point.

Le constructeur : __construct

Le constructeur est la méthode spéciale __construct(), appelée automatiquement par new. C'est là qu'on initialise l'objet.

class Compte {
    public string $titulaire;
    public float $solde = 0;

    public function __construct(string $titulaire) {
        $this->titulaire = $titulaire;
    }
}

$compte = new Compte("Alice");   // __construct est appelé ici
echo $compte->titulaire;          // Alice

// Version courte (PHP 8) : déclare ET affecte $titulaire d'un coup
class Compte {
    public float $solde = 0;
    public function __construct(public string $titulaire) {}
}

Fabrique des objets (exécute !)

Une vraie classe PHP qui tourne sur le serveur. Chaque new Compte(...) crée un objet indépendant, avec son propre solde. Modifie le code, puis clique sur « Run ».

<?php
class Compte {
    public float $solde = 0;

    public function __construct(public string $titulaire) {}

    public function deposer(float $montant): void {
        $this->solde += $montant;
    }

    public function resume(): string {
        return "{$this->titulaire} : {$this->solde} €";
    }
}

$alice = new Compte("Alice");
$alice->deposer(120);

$bob = new Compte("Bob");      // un objet distinct, son propre solde

echo $alice->resume() . "\n";  // Alice : 120 €
echo $bob->resume() . "\n";    // Bob : 0 €
?>

À retenir

• Une classe se déclare avec class Nom { ... } ; on en fabrique des objets avec new Nom(...).
• Les propriétés portent un type (float, string…) et, idéalement, une visibilité (on verra public/private à la prochaine leçon).
• $this désigne l'objet courant ; on accède à ses membres avec ->.
• Le constructeur __construct() initialise l'objet ; la promotion (PHP 8) le raccourcit.

Propriétés et méthodes statiques

Jusqu'ici, chaque objet possède ses propres propriétés : $alice->solde et $bob->solde sont des cases mémoire distinctes. Un membre statique fonctionne différemment : il appartient à la classe elle-même, pas à une instance. Il est partagé par tous les objets de cette classe, et accessible sans créer d'objet.

On le déclare avec le mot-clé static, et on y accède avec l'opérateur :: (double deux-points), appelé opérateur de résolution de portée :

• Depuis l'extérieur de la classe : Compte::$compteur
• Depuis l'intérieur de la classe : self::$compteur

Cas d'usage typiques : un compteur d'instances (incrémenté dans __construct pour savoir combien d'objets ont été créés), ou une méthode utilitaire / fabrique (factory) qui n'a pas besoin d'un objet existant pour fonctionner.

<?php
class Compte {
    public static int $compteur = 0;   // propriété de classe, pas d'instance
    public string $titulaire;

    public function __construct(string $titulaire) {
        $this->titulaire = $titulaire;
        self::$compteur++;             // incrémente le compteur partagé
    }

    public static function reinitialiser(): void {
        self::$compteur = 0;
    }
}

$a = new Compte("Alice");
$b = new Compte("Bob");
$c = new Compte("Charlie");

echo Compte::$compteur;  // 3 (pas besoin d'instance pour y accéder)
?>

Les méthodes magiques

PHP réserve un ensemble de méthodes dont les noms commencent par __ (double underscore). Tu en connais déjà une : __construct. Ce sont des méthodes que PHP appelle automatiquement dans certaines situations, sans que tu les appelles toi-même.

Les plus utiles à connaître :

• __toString(): string : appelée quand l'objet est utilisé comme une chaîne (dans un echo, une concaténation, un sprintf...). Très pratique pour afficher un objet lisiblement, en débogage ou en log.
• __get($nom) et __set($nom, $valeur) : interceptent la lecture et l'écriture d'une propriété inaccessible ou inexistante. Utile pour des objets dynamiques, du logging automatique ou de la validation à la volée.

Il en existe d'autres (__call, __invoke, __clone...), mais le principe reste le même : PHP les appelle dans un contexte précis. À utiliser avec parcimonie : le code explicite reste plus lisible que le comportement « magique » quand les deux sont possibles.

<?php
class Produit {
    public string $nom;
    public float $prix;

    public function __construct(string $nom, float $prix) {
        $this->nom  = $nom;
        $this->prix = $prix;
    }

    public function __toString(): string {
        return "{$this->nom} ({$this->prix} €)";
    }
}

$p = new Produit("Clavier", 49.90);
echo $p;  // PHP appelle __toString automatiquement : Clavier (49.9 €)
?>