Les classes et les objets

Pourquoi des objets ?

Imagine une application bancaire. Pour chaque compte, il faut le nom du titulaire et le solde, et des actions : déposer, retirer. Avec ce que tu connais, tu ferais un tableau associatif par compte et des fonctions à côté. Ça marche, mais rien n'empêche d'écrire $compte["solde"] = -1000000; par erreur, et les fonctions sont séparées des données qu'elles modifient.

La programmation orientée objet range ensemble les données et les actions. Deux mots à connaître :

• une classe est un plan : elle décrit ce qu'a et ce que sait faire un compte ;
• un objet est une chose construite à partir de ce plan : le compte de Léa, le compte de Tom. On peut en créer autant qu'on veut avec la même classe.

Déclarer une classe, créer un objet

Une classe se déclare avec le mot class suivi de son nom, qui commence par une majuscule (c'est l'usage). À l'intérieur, les propriétés sont les variables de l'objet.

<?php
class Compte
{
    public string $titulaire = "";
    public float $solde = 0;
}

$compteLea = new Compte();          // on construit un objet à partir du plan
$compteLea->titulaire = "Léa";      // -> pour accéder à une propriété
$compteLea->solde = 150;

$compteTom = new Compte();          // un deuxième objet, indépendant du premier
$compteTom->titulaire = "Tom";

echo $compteLea->titulaire . " a " . $compteLea->solde . " €";   // Léa a 150 €
echo $compteTom->solde;                                           // 0

• new Compte() crée un nouvel objet ;
• la flèche -> accède à une propriété de l'objet (attention : pas de $ devant le nom de la propriété) ;
• public veut dire que la propriété est utilisable partout. On verra plus bas pourquoi on préfère souvent private.

Les méthodes et $this

Une méthode est une fonction écrite dans la classe : c'est une action que l'objet sait faire. Dans une méthode, $this désigne l'objet sur lequel on l'a appelée.

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

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

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

$compteLea = new Compte();
$compteLea->titulaire = "Léa";
$compteLea->deposer(100);
$compteLea->deposer(50);
echo $compteLea->decrire();     // Léa a 150 €

Quand on écrit $compteLea->deposer(100), PHP exécute la méthode deposer avec $this = $compteLea. Si on l'appelait sur $compteTom, $this serait $compteTom. Le mot void indique que la méthode ne renvoie rien.

Le constructeur

Créer un objet puis remplir ses propriétés une par une, c'est long, et on peut oublier une étape. Le constructeur est une méthode spéciale, __construct (avec deux tirets bas), appelée automatiquement par new. Les valeurs données entre les parenthèses de new lui sont transmises.

<?php
class Compte
{
    public string $titulaire;
    public float $solde;

    public function __construct(string $titulaire, float $solde = 0)
    {
        $this->titulaire = $titulaire;
        $this->solde = $solde;
    }
}

$compteLea = new Compte("Léa", 150);   // le constructeur reçoit "Léa" et 150
$compteTom = new Compte("Tom");        // solde = 0 par défaut

Depuis PHP 8, il existe un raccourci : en mettant public (ou private) devant un paramètre du constructeur, PHP crée la propriété et la remplit tout seul. Les deux versions font exactement la même chose :

<?php
class Compte
{
    public function __construct(public string $titulaire, public float $solde = 0)
    {
    }
}

Protéger les propriétés : private

Avec public, n'importe quel code peut écrire $compte->solde = -1000000;. Avec private, la propriété n'est utilisable qu'à l'intérieur de la classe. Le reste du programme doit passer par des méthodes publiques, qui peuvent vérifier les valeurs. C'est l'encapsulation.

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

    public function __construct(public string $titulaire)
    {
    }

    public function deposer(float $montant): void
    {
        if ($montant <= 0) {
            echo "Montant refusé";
            return;
        }
        $this->solde += $montant;
    }

    public function getSolde(): float
    {
        return $this->solde;
    }
}

$compte = new Compte("Léa");
$compte->deposer(80);
echo $compte->getSolde();     // 80
echo $compte->solde;          // Erreur : Cannot access private property Compte::$solde

Une méthode qui sert seulement à lire une propriété privée s'appelle un accesseur (en anglais « getter ») : par convention, son nom commence par get. Ici, le solde ne peut changer que par deposer(), qui refuse les montants négatifs.

Astuce : $this->solde += $montant; est un raccourci pour $this->solde = $this->solde + $montant;. Il existe aussi -=, *=…

Attention : pas de $ après la flèche. On écrit $this->solde, jamais $this->$solde.