Programmation Orientée Objet en PHP 🏗️

La POO est un paradigme puissant qui organize ton code en classes et objets. PHP supporte pleinement la POO depuis la version 5, avec des fonctionnalités modernes en PHP 8.

Classes et objets de base

<?php
class Animal {
    // Propriétés (attributs)
    public string $nom;
    public string $espece;
    protected int $age;

    // Constructeur
    public function __construct(string $nom, string $espece, int $age) {
        $this->nom = $nom;
        $this->espece = $espece;
        $this->age = $age;
    }

    // Méthode
    public function presenter(): string {
        return "Je suis $this->nom, un $this->espece de $this->age ans.";
    }

    // Getter
    public function getAge(): int {
        return $this->age;
    }
}

// Créer un objet (pas de "new" nécessaire avec les parenthèses)
$chat = new Animal("Minou", "Chat", 3);
echo $chat->presenter(); // Je suis Minou, un Chat de 3 ans.
?>

Visibilité (public, protected, private)

<?php
class CompteBancaire {
    public string $titulaire;      // Visible partout
    protected float $solde;        // Visible dans la classe et les enfants
    private string $codeSecret;    // Visible UNIQUEMENT dans la classe

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

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

    private function validerCode(string $code): bool {
        return $code === $this->codeSecret;
    }

    public function retirer(float $montant, string $code): bool {
        if (!$this->validerCode($code)) {
            echo "Code incorrect !";
            return false;
        }
        if ($montant > $this->solde) {
            echo "Solde insuffisant !";
            return false;
        }
        $this->solde -= $montant;
        return true;
    }
}

$compte = new CompteBancaire("Alice", 1000, "1234");
echo $compte->titulaire;   // OK (public)
echo $compte->getSolde();  // OK (méthode publique)
// echo $compte->solde;    // ERREUR (protected)
// echo $compte->codeSecret; // ERREUR (private)
?>

Héritage

<?php
class Vehicule {
    public function __construct(
        public string $marque,
        public int $annee
    ) {}

    public function decrire(): string {
        return "$this->marque ($this->annee)";
    }

    public function demarrer(): string {
        return "Le véhicule démarre...";
    }
}

class Voiture extends Vehicule {
    public function __construct(
        string $marque,
        int $annee,
        public int $portes
    ) {
        parent::__construct($marque, $annee);
    }

    public function decrire(): string {
        return parent::decrire() . " — $this->portes portes";
    }

    public function klaxonner(): string {
        return "Pin Pon !";
    }
}

class Moto extends Vehicule {
    public function demarrer(): string {
        return "Vroooom !";
    }
}

$voiture = new Voiture("Renault", 2023, 5);
echo $voiture->decrire();     // Renault (2023) — 5 portes
echo $voiture->klaxonner();   // Pin Pon !
echo $voiture->demarrer();    // Le véhicule démarre...

$moto = new Moto("Yamaha", 2022);
echo $moto->demarrer();       // Vroooom !
?>

Interfaces et classes abstraites

<?php
// Interface — contrat que les classes doivent respecter
interface Dessinable {
    public function dessiner(): string;
    public function getTaille(): int;
}

interface Redimensionnable {
    public function redimensionner(int $facteur): void;
}

// Classe abstraite — ne peut pas être instanciée directement
abstract class Forme {
    abstract public function aire(): float;
    abstract public function perimetre(): float;

    public function description(): string {
        return "Aire: " . $this->aire() . ", Périmètre: " . $this->perimetre();
    }
}

class Cercle extends Forme implements Dessinable {
    public function __construct(private float $rayon) {}

    public function aire(): float {
        return pi() * $this->rayon ** 2;
    }

    public function perimetre(): float {
        return 2 * pi() * $this->rayon;
    }

    public function dessiner(): string {
        return "○";
    }

    public function getTaille(): int {
        return (int)$this->rayon;
    }
}

class Rectangle extends Forme implements Dessinable, Redimensionnable {
    public function __construct(
        private float $largeur,
        private float $hauteur
    ) {}

    public function aire(): float {
        return $this->largeur * $this->hauteur;
    }

    public function perimetre(): float {
        return 2 * ($this->largeur + $this->hauteur);
    }

    public function dessiner(): string {
        return "□";
    }

    public function getTaille(): int {
        return (int)$this->largeur;
    }

    public function redimensionner(int $facteur): void {
        $this->largeur *= $facteur;
        $this->hauteur *= $facteur;
    }
}

// Utilisation
$formes = [new Cercle(5), new Rectangle(4, 6)];
foreach ($formes as $f) {
    echo $f->description() . "\n";
    echo $f->dessiner() . "\n";
}
?>

PHP 8+ : Named Arguments, Enums, Readonly

<?php
// PHP 8.0 — Named arguments
class Config {
    public function __construct(
        public string $host = "localhost",
        public int $port = 3306,
        public string $db = "test",
        public string $charset = "utf8mb4"
    ) {}
}

$config = new Config(db: "production", port: 3307);

// PHP 8.1 — Enums
enum Statut: string {
    case EnCours = "en_cours";
    case Termine = "termine";
    case Annule = "annule";

    public function label(): string {
        return match($this) {
            self::EnCours => "En cours",
            self::Termine => "Terminé",
            self::Annule => "Annulé",
        };
    }
}

$tache = Statut::EnCours;
echo $tache->value;   // en_cours
echo $tache->label(); // En cours

// PHP 8.2 — Readonly classes
readonly class Point {
    public function __construct(
        public float $x,
        public float $y
    ) {}
}

$p = new Point(3.0, 4.0);
// $p->x = 5.0; // ERREUR — readonly !
?>

Traits (réutilisation de code)

<?php
trait Timestampable {
    public string $creeLe;
    public string $misAJourLe;

    public function initTimestamps(): void {
        $this->creeLe = date('Y-m-d H:i:s');
        $this->misAJourLe = $this->creeLe;
    }

    public function touch(): void {
        $this->misAJourLe = date('Y-m-d H:i:s');
    }
}

trait Sluggable {
    public string $slug;

    public function generateSlug(string $titre): string {
        $this->slug = strtolower(
            preg_replace('/[^a-zA-Z0-9]+/', '-', $titre)
        );
        return $this->slug;
    }
}

class Article {
    use Timestampable, Sluggable;

    public function __construct(public string $titre, public string $contenu) {
        $this->initTimestamps();
        $this->generateSlug($titre);
    }
}

$article = new Article("Mon Premier Article", "Du contenu...");
echo $article->slug;     // mon-premier-article
echo $article->creeLe;   // 2026-07-17 ...
?>

Comparaison avec JavaScript

🎯 A retenir : La POO en PHP est puissante et moderne. Utilise les interfaces pour définir des contrats, les traits pour partager du code, et les enums pour les listes de valeurs fixes.

---

Prochaine leçon : PHP et les bases de données — connecte-toi à MySQL !