POO en PHP – BTS SIO SLAM (Cours + Exercices)

Ce cours rappelle les concepts essentiels de la programmation orientée objet (POO) en PHP : classes, objets, encapsulation, constructeurs, héritage, abstraction & interfaces, polymorphisme, traits, et un aperçu pratique avec PDO (sans ORM).

1. Classe et Objet

Concept : Une classe est un modèle qui définit des attributs (données) et des méthodes (comportements). Un objet est une instance concrète d’une classe : on peut lui affecter des valeurs et appeler ses méthodes.

Exemple

<?php
class Voiture {
    public string $marque;
    public string $couleur;

    public function demarrer(): void {
        echo "La voiture démarre \n";
    }
}

$maVoiture = new Voiture();
$maVoiture->marque = "Peugeot";
$maVoiture->couleur = "Rouge";
$maVoiture->demarrer();

Exercice

1. Créer une classe Livre avec deux attributs publics titre et auteur.
2. Instancier deux objets (ex : “1984” de George Orwell, “Le Petit Prince” de Saint-Exupéry).
3. Afficher leurs informations au format Titre — Auteur.

2. Encapsulation et Constructeur

Concept : L’encapsulation protège les données via des attributs private et un accès contrôlé par des méthodes (getters/setters). Le constructeur __construct initialise l’objet dès sa création (valeurs obligatoires, valeurs par défaut, invariants).

Exemple

<?php
class CompteBancaire {
    private string $titulaire;
    private float $solde;

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

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

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

$compte = new CompteBancaire("Alice", 100);
$compte->deposer(50);
echo "Solde : " . $compte->getSolde(); // 150

Exercice

1. Créer une classe Etudiant avec attributs privés nom, note (float).
2. Ajouter un constructeur, des getters (et un setter pour note avec validation : 0 ≤ note ≤ 20).
3. Ajouter une méthode afficher() qui imprime Nom : X — Note : Y.

3. Héritage

Concept : L’héritage permet à une classe dérivée (fille) de réutiliser et spécialiser une classe de base (mère). On réduit la duplication et on modélise des hiérarchies (ex. Vehicule → Moto, Voiture).

Exemple

<?php
class Animal {
    public function crier(): void {
        echo "L’animal fait un bruit.\n";
    }
}

class Chien extends Animal {
    public function crier(): void {
        echo "Woof !\n";
    }
}

$rex = new Chien();
$rex->crier(); // Woof !

Exercice

1. Créer une classe Vehicule avec méthode rouler() qui affiche Le véhicule roule.
2. Créer une classe Moto qui extends Vehicule et redéfinit rouler() en La moto roule 🏍️.
3. Instancier Moto et appeler rouler().

4. Classes Abstraites et Interfaces

Concept : Une classe abstraite définit une interface partielle et/ou du code commun, mais n’est pas instanciable. Une interface n’a pas d’implémentation : elle impose un contrat (liste de méthodes) aux classes qui l’implémentent. On sépare le contrat de l’implémentation.

Exemple

<?php
abstract class Forme {
    abstract public function aire(): float;
}

interface Deplacable {
    public function deplacer(int $x, int $y): void;
}

class Cercle extends Forme implements Deplacable {
    private float $rayon;

    public function __construct(float $rayon) { $this->rayon = $rayon; }

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

    public function deplacer(int $x, int $y): void {
        echo "Cercle déplacé en ({$x}, {$y})\n";
    }
}

$c = new Cercle(5);
echo "Aire : " . $c->aire() . "\n";
$c->deplacer(2, 3);

Exercice

1. Définir une classe abstraite Employe avec méthode abstraite calculerSalaire(): float.
2. Créer Ouvrier et Manager qui héritent de Employe avec des calculs de salaire différents.
3. Instancier et afficher les salaires de plusieurs employés.

5. Polymorphisme

Concept : Le polymorphisme permet d’appeler la même méthode sur des objets de types différents, chaque classe fournissant son propre comportement. On écrit du code générique (ex. boucles sur une collection d’objets hétérogènes).

Exemple

<?php
class Employe {
    public function calculerSalaire(): float { return 2000.0; }
}

class Manager extends Employe {
    public function calculerSalaire(): float { return 3000.0; }
}

$employes = [new Employe(), new Manager()];
foreach ($employes as $e) {
    echo "Salaire : " . $e->calculerSalaire() . "\n";
}

Exercice

1. Reprendre Ouvrier et Manager (section précédente) et ajouter une méthode presenter(): void différente dans chaque classe.
2. Créer un tableau d’employés mixtes et appeler presenter() dans une boucle.

6. Traits

Concept : Un trait regroupe des méthodes réutilisables et composables dans plusieurs classes, sans passer par l’héritage. Utile pour des fonctionnalités transverses (journalisation, horodatage, formatage).

Exemple

<?php
trait Logger {
    public function log(string $message): void {
        echo "[LOG] {$message}\n";
    }
}

class Service {
    use Logger;

    public function executer(): void {
        $this->log("Service exécuté !");
    }
}

$s = new Service();
$s->executer();

Exercice

1. Créer un trait Horodatage avec une méthode maintenant(): string qui retourne la date/heure courante (format ISO 8601).
2. L’utiliser dans une classe Commande et afficher Commande enregistrée à [date/heure] lors d’un appel à enregistrer().

7. POO + Base de Données avec PDO (sans ORM)

Concept : Avec PDO, on interagit avec MySQL tout en gardant une modélisation objet. On crée des classes métier (entités), on mappe les lignes SQL vers des objets, et on isole l’accès aux données dans des repositories ou DAO.

Exemple (lecture simple)

<?php
class Utilisateur {
    public function __construct(
        private int $id,
        private string $nom
    ) {}

    public function getId(): int { return $this->id; }
    public function getNom(): string { return $this->nom; }
}

class UtilisateurRepository {
    public function __construct(private PDO $pdo) {}

    /** @return Utilisateur[] */
    public function findAll(): array {
        $stmt = $this->pdo->query("SELECT id, nom FROM utilisateurs");
        $users = [];
        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
            $users[] = new Utilisateur((int)$row['id'], (string)$row['nom']);
        }
        return $users;
    }

    public function insert(string $nom): int {
        $stmt = $this->pdo->prepare("INSERT INTO utilisateurs(nom) VALUES(:nom)");
        $stmt->execute([':nom' => $nom]);
        return (int)$this->pdo->lastInsertId();
    }
}

try {
    $pdo = new PDO("mysql:host=localhost;dbname=test;charset=utf8mb4", "root", "", [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    ]);

    $repo = new UtilisateurRepository($pdo);
    $nouvelId = $repo->insert("Alice");
    echo "Nouvel utilisateur id = {$nouvelId}\n";

    foreach ($repo->findAll() as $u) {
        echo $u->getId() . " — " . $u->getNom() . "\n";
    }

} catch (PDOException $e) {
    echo "Erreur PDO : " . $e->getMessage();
}

Exercice

1. Créer une table produits : id INT AI PK, nom VARCHAR(100), prix DECIMAL(10,2).
2. Écrire une classe Produit (id, nom, prix) et un ProduitRepository avec méthodes findAll(), findById(int $id), insert(string $nom, float $prix).
3. Insérer 2–3 produits et les afficher en parcourant la collection d’objets.

Conclusion

• Bases : classes, objets, encapsulation, constructeurs.
• Structure : héritage, abstraction, interfaces, polymorphisme, traits.
• Pratique : accès aux données en POO avec PDO (sans ORM).