Utiliser l'orienté objet en PHP

<?php
class Voiture
{
    // propriétés
    public string $marque;
    public string $couleur;
    private int $vitesse = 0;

    // constructeur : appelé automatiquement par new
    public function __construct(string $marque, string $couleur = 'Blanche')
    {
        $this->marque = $marque;
        $this->couleur = $couleur;
    }

    // méthodes
    public function accelerer(int $kmh): void
    {
        $this->vitesse = min($this->vitesse + $kmh, 180);
    }

    public function freiner(): void
    {
        $this->vitesse = 0;
    }

    public function getVitesse(): int
    {
        return $this->vitesse;
    }
}

$maVoiture = new Voiture('Dacia', 'Rouge');      // instanciation
$maVoiture->accelerer(50);                        // -> pour accéder aux membres
echo $maVoiture->marque . ' roule à ' . $maVoiture->getVitesse() . ' km/h';   // Dacia roule à 50 km/h

<?php
class Stagiaire
{
    public function __construct(
        public string $nom,
        public string $prenom,
        private array $notes = [],
    ) {}                                    // les propriétés sont déclarées ET affectées

    public function ajouterNote(float $note): void
    {
        if ($note < 0 || $note > 20) {
            throw new InvalidArgumentException("Note invalide : $note");
        }
        $this->notes[] = $note;
    }

    public function moyenne(): float
    {
        return $this->notes ? round(array_sum($this->notes) / count($this->notes), 2) : 0.0;
    }
}

$s = new Stagiaire('Benali', 'Sara');
$s->ajouterNote(15);
$s->ajouterNote(17.5);
echo $s->moyenne();       // 16.25

<?php
class Compte
{
    public readonly string $numero;           // readonly (PHP 8.1) : affectable une seule fois
    private float $solde = 0;

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

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

    public function deposer(float $montant): void
    {
        if ($montant <= 0) {
            throw new InvalidArgumentException('Montant invalide');
        }
        $this->solde += $montant;
    }
}

$c = new Compte('MA001');
$c->deposer(500);
echo $c->getSolde();       // 500
// $c->solde = 1000000;    // Error : Cannot access private property
// $c->numero = 'MA002';   // Error : Cannot modify readonly property

<?php
class Personne
{
    public function __construct(protected string $nom, protected string $prenom) {}

    public function presenter(): string
    {
        return "{$this->prenom} {$this->nom}";
    }
}

class Formateur extends Personne                      // Formateur HÉRITE de Personne
{
    public function __construct(string $nom, string $prenom, private string $module)
    {
        parent::__construct($nom, $prenom);           // appeler le constructeur parent
    }

    public function presenter(): string               // redéfinition
    {
        return parent::presenter() . ", formateur de {$this->module}";
    }
}

$f = new Formateur('Tazi', 'Youssef', 'M107');
echo $f->presenter();      // Youssef Tazi, formateur de M107
var_dump($f instanceof Personne);   // bool(true)

<?php
class Stagiaire2
{
    public static int $nombre = 0;              // partagé par toute la classe
    public const ETABLISSEMENT = 'ISTA NTIC';   // constante de classe

    public function __construct(public string $nom)
    {
        self::$nombre++;                        // self:: pour la classe elle-même
    }

    public static function compter(): int
    {
        return self::$nombre;
    }
}

new Stagiaire2('Sara');
new Stagiaire2('Ali');
echo Stagiaire2::compter();           // 2   (:: opérateur de résolution de portée)
echo Stagiaire2::ETABLISSEMENT;       // ISTA NTIC

<?php
interface Imprimable
{
    public function imprimer(): string;
}

abstract class Forme implements Imprimable          // ne peut pas être instanciée
{
    abstract public function surface(): float;       // les filles DOIVENT l'implémenter

    public function imprimer(): string
    {
        return static::class . ' : ' . round($this->surface(), 2);
    }
}

class Cercle extends Forme
{
    public function __construct(private float $rayon) {}
    public function surface(): float { return M_PI * $this->rayon ** 2; }
}

class Rectangle extends Forme
{
    public function __construct(private float $l, private float $h) {}
    public function surface(): float { return $this->l * $this->h; }
}

$formes = [new Cercle(1), new Rectangle(4, 3)];
foreach ($formes as $f) {
    echo $f->imprimer() . "\n";      // polymorphisme : Cercle : 3.14, puis Rectangle : 12
}

<?php
namespace App\Modele;

class Stagiaire
{
    public function __construct(public string $nom) {}
}

<?php
spl_autoload_register(function (string $classe) {
    // App\Modele\Stagiaire  →  src/Modele/Stagiaire.php
    $chemin = __DIR__ . '/src/' . str_replace(['App\\', '\\'], ['', '/'], $classe) . '.php';
    if (is_file($chemin)) {
        require $chemin;
    }
});

use App\Modele\Stagiaire;

$s = new Stagiaire('Benali');      // le fichier est chargé automatiquement au premier usage

<?php
class A {
    public function __construct(protected int $x = 1) {}
    public function valeur(): int { return $this->x; }
    public function __toString(): string { return static::class . '(' . $this->valeur() . ')'; }
}
class B extends A {
    public function valeur(): int { return parent::valeur() * 10; }
}
$objets = [new A(), new B(2), new A(5)];
foreach ($objets as $o) echo $o, ' ';
echo "\n", count(array_filter($objets, fn($o) => $o instanceof A));

<?php
class Produit
{
    private array $donnees = [];

    public function __construct(private string $nom, private float $prix) {}

    public function __toString(): string
    {
        return sprintf('%s (%.2f DH)', $this->nom, $this->prix);
    }

    public function __get(string $cle): mixed
    {
        return $this->donnees[$cle] ?? null;
    }

    public function __set(string $cle, mixed $valeur): void
    {
        $this->donnees[$cle] = $valeur;
    }

    public function __call(string $methode, array $args): mixed
    {
        if (str_starts_with($methode, 'get')) {          // getCouleur() → donnees['couleur']
            return $this->donnees[strtolower(substr($methode, 3))] ?? null;
        }
        throw new BadMethodCallException("Méthode $methode inconnue");
    }

    public function __destruct()
    {
        // fermer une ressource, écrire un journal…
    }
}

$p = new Produit('Clavier', 249.9);
echo $p;                 // Clavier (249.90 DH)     ← __toString
$p->couleur = 'noir';    // __set
echo $p->couleur;        // noir                     ← __get
echo $p->getCouleur();   // noir                     ← __call