Module 5 – Programmation Orientée Objet (POO)

Niveau 2 – PHP avancé

---

Objectifs

Classes et objets, encapsulation, héritage, polymorphisme, visibilité (public, protected, private). On voit aussi l’autoloading PSR-4 pour structurer le code en namespaces.

---

Théorie

Classes et objets

Une classe est un modèle qui décrit la structure (propriétés) et le comportement (méthodes) des objets. Un objet est une instance d’une classe.

class User {
    public string $firstName;
    public string $lastName;
    public int $age;

    public function __construct(string $firstName, string $lastName, int $age) {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
        $this->age = $age;
    }

    public function fullName(): string {
        return $this->firstName . " " . $this->lastName;
    }
}

$user = new User("Mary", "Doe", 28);
echo $user->fullName();  // Mary Doe
echo $user->age;         // 28

• __construct : constructeur, appelé avec new User(...).
• $this : référence à l’instance courante (accès aux propriétés et méthodes).
• Propriétés : variables attachées à l’objet. Méthodes : fonctions attachées à l’objet.

---

Encapsulation et visibilité

L’encapsulation consiste à cacher les détails internes et à n’exposer qu’une interface claire. La visibilité définit qui peut accéder aux propriétés et méthodes.

Visibilité	Accès
public	Partout (classe, sous-classes, code externe)
protected	Dans la classe et les sous-classes uniquement
private	Dans la classe uniquement

Bon usage : propriétés en private (ou protected si héritage), et exposition via des méthodes (getters/setters) si besoin.

class Product {
    private string $name;
    private float $price;

    public function __construct(string $name, float $price) {
        $this->name = $name;
        $this->price = $price;
    }

    public function getName(): string {
        return $this->name;
    }
    public function getPrice(): float {
        return $this->price;
    }
    public function setPrice(float $price): void {
        if ($price >= 0) {
            $this->price = $price;
        }
    }
}

---

Héritage

Une classe peut hériter d’une autre : elle récupère ses propriétés et méthodes (sauf private). On utilise extends.

class Animal {
    protected string $name;
    public function __construct(string $name) { $this->name = $name; }
    public function eat(): string { return $this->name . " eats."; }
}

class Dog extends Animal {
    public function bark(): string { return $this->name . " barks."; }
}

$dog = new Dog("Rex");
echo $dog->eat();   // Rex eats.
echo $dog->bark();  // Rex barks.

Override (surcharge) : une sous-classe peut redéfinir une méthode. Appeler la méthode parent avec parent:: :

class Dog extends Animal {
    public function eat(): string {
        return parent::eat() . " (kibble)";
    }
}

---

Polymorphisme

Le polymorphisme permet de traiter des objets de types différents via une même interface. Une méthode peut accepter un type parent et recevoir des instances de sous-classes.

function feed(Animal $a): void {
    echo $a->eat();
}
feed(new Dog("Rex"));    // OK: Dog is an Animal
feed(new Cat("Felix"));  // OK if Cat extends Animal

---

Propriétés typées et constructeur (PHP 8)

En PHP 8+, on peut déclarer les types des propriétés et promouvoir les paramètres du constructeur en propriétés :

class User {
    public function __construct(
        private string $firstName,
        private string $lastName,
        private int $age = 0,
    ) {}
}

Les paramètres private deviennent automatiquement des propriétés.

---

Autoloading PSR-4

L’autoloading charge une classe automatiquement au premier usage, sans require manuel. PSR-4 associe un namespace à un dossier.

Structure de dossiers :

projet/
├── src/
│   └── App/
│       ├── User.php    → namespace App;
│       └── Service/
│           └── Mailer.php     → namespace App\Service;
├── composer.json

composer.json :

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Puis : composer dump-autoload.

User.php :

<?php
namespace App;

class User {
    // ...
}

Usage:

<?php
require_once 'vendor/autoload.php';
use App\User;
$u = new User("Mary", "Doe", 28);

Une classe dans App\Service\Mailer doit être dans src/App/Service/Mailer.php et déclarer namespace App\Service;.

---

Exemples

Exemple 1 : Compte bancaire (encapsulation)

class BankAccount {
    private float $balance = 0;

    public function deposit(float $amount): void {
        if ($amount > 0) $this->balance += $amount;
    }
    public function withdraw(float $amount): bool {
        if ($amount > 0 && $amount <= $this->balance) {
            $this->balance -= $amount;
            return true;
        }
        return false;
    }
    public function getBalance(): float {
        return $this->balance;
    }
}

Exemple 2 : Héritage et override

class Shape {
    public function area(): float { return 0; }
}
class Rectangle extends Shape {
    public function __construct(private float $w, private float $h) {}
    public function area(): float { return $this->w * $this->h; }
}
class Square extends Rectangle {
    public function __construct(float $side) { parent::__construct($side, $side); }
}

---

En pratique

1. Une classe = une responsabilité (principe SRP).
2. Préférer private pour les propriétés, exposer via des méthodes si nécessaire.
3. Typer les propriétés et les paramètres/retours des méthodes (PHP 7+ / 8+).
4. Namespace PSR-4 : un namespace par dossier, nom de fichier = nom de la classe.

---

Quiz – Module 5

Q1. Quelle est la différence entre une classe et un objet ?
Q2. Que signifie $this ?
Q3. Quelle visibilité permet l’accès uniquement dans la classe ?
Q4. Comment une sous-classe appelle-t-elle une méthode de la classe parente ?
Q5. À quoi sert l’autoloading PSR-4 ?

Réponses

R1. La classe est le modèle (structure + comportement). L’objet est une instance concrète créée avec new.

R2. $this est la référence à l’instance courante (l’objet sur lequel la méthode est appelée).

R3. private.

R4. Avec parent::methodName() (ou parent:: pour une propriété protected).

R5. À charger automatiquement le fichier d’une classe au premier usage, en associant namespace et dossiers (éviter les require manuels).

---

Projet : Mini système orienté objet

Sujet : Modéliser un système simple (ex. bibliothèque : Book, Member, Loan) avec au moins 2 classes, des propriétés private, des getters/setters, un constructeur et une méthode métier (ex. borrow(), returnItem()). Utiliser l’autoloading PSR-4 et des namespaces.

Critères : Code dans un dossier src/, composer.json avec PSR-4, au moins un héritage ou une utilisation de type hint sur une classe parente (polymorphisme).

---

Suite

Module 6 – PHP moderne (PHP 8+) : typage strict, union types, attributes, match, nullsafe operator.