Classes et objets en PHP — Cours PHP orienté objet

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

Raccourci PHP 8 : la promotion de propriétés. Au lieu de déclarer la propriété puis de l'affecter dans le constructeur, on met la visibilité directement dans les paramètres. Ces deux versions sont équivalentes :

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

Accepter ou rejeter le code de l'IA

Tu demandes une classe Compte à l'IA. Ton rôle de relecteur : accepter ce code tel quel ou le rejeter, et dire pourquoi.

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

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

$c = new Compte();
$c->titulaire = "Alice";
$c->solde = 999999;   // l'IA initialise le solde comme ça

À corriger plutôt qu'accepter tel quel. Le code tourne, mais deux signaux gênent. D'abord $solde est public : n'importe qui peut écrire $c->solde = 999999 et casser l'invariant du compte (c'est exactement ce que la prochaine leçon ferme avec la visibilité). Ensuite il n'y a pas de __construct() : on fabrique un objet à moitié vide puis on remplit les propriétés à la main, ce qui autorise un Compte sans titulaire. Le réflexe pro : un constructeur qui exige le titulaire et un solde non modifiable directement de l'extérieur.

Rappel libre

Sans remonter dans la leçon : à quoi sert new Compte("Alice"), et que désigne $this à l'intérieur d'une méthode ?

new Compte("Alice") fabrique un nouvel objet à partir de la classe (le moule) et appelle automatiquement son __construct("Alice") pour l'initialiser ; chaque appel crée un objet indépendant, avec ses propres propriétés. À l'intérieur d'une méthode, $this désigne l'objet courant, celui sur lequel la méthode a été appelée, et on accède à ses membres avec la flèche -> (ex. $this->solde).

En PHP, comment accède-t-on à une méthode d'un objet ?

Avec un point : objet.methode() Avec une flèche : $objet->methode() Avec deux-points : objet::methode()

À quoi sert __construct() ?

À détruire l'objet À afficher l'objet À initialiser l'objet au moment du new

Prochaine étape

Pour l'instant, $solde est public : n'importe qui peut écrire $compte->solde = 999999. La prochaine leçon ferme cette porte avec la visibilité.

Leçon 2 : visibilité →

From theory to PHP syntax

In the course « OOP explained simply », you saw the ideas: an object groups properties (data) and methods (actions), and a class is the mold. Here, we translate all that into concrete PHP, and you run it directly.

A reassuring note: PHP's object syntax looks a lot like Java, C# or JavaScript. Learning it here means learning it almost everywhere.

Declaring a class

The class keyword, properties (typed, it's better) and methods. Inside, $this refers to the current object.

class Compte {
    public string $titulaire;     // a typed property
    public float $solde = 0;       // with a default value

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

Note the -> (arrow): in PHP, you access an object's properties and methods with $object->property and $object->method(), not with a dot.

The constructor: __construct

The constructor is the special method __construct(), called automatically by new. That's where you initialize the object.

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

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

$compte = new Compte("Alice");   // __construct is called here
echo $compte->titulaire;          // Alice

PHP 8 shortcut: constructor property promotion. Instead of declaring the property then assigning it in the constructor, put the visibility directly in the parameters. These two versions are equivalent:

// Short version (PHP 8): declares AND assigns $titulaire at once
class Compte {
    public float $solde = 0;
    public function __construct(public string $titulaire) {}
}

Build objects (run it!)

A real PHP class running on the server. Each new Compte(...) creates an independent object, with its own balance. Edit the code, then click "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");      // a distinct object, its own balance

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

Key takeaways

A class is declared with class Name { ... }; you build objects with new Name(...).
Properties carry a type (float, string…) and, ideally, a visibility (we'll see public/private next lesson).
$this refers to the current object; you access its members with ->.
The constructor __construct() initializes the object; promotion (PHP 8) shortens it.

Next step

For now, $solde is public: anyone can write $compte->solde = 999999. The next lesson closes that door with visibility.

Lesson 2: visibility →