Module PHP.9 – Programmation Orientée Objet

Objectif

Maîtriser la POO en PHP : classes, objets, propriétés, méthodes, constructeurs, visibilité, héritage, interfaces, traits et namespaces.

Théorie

Classes & objets

Définition d'une classe :

class Personne {
    // Propriétés
    public $nom;
    public $age;
    
    // Méthodes
    public function saluer() {
        return "Bonjour, je suis " . $this->nom;
    }
}

Création d'un objet :

$jean = new Personne();
$jean->nom = "Jean";
$jean->age = 30;
echo $jean->saluer();

Propriétés & méthodes

Propriétés :

class Personne {
    public $nom;        // Accessible partout
    private $age;       // Accessible seulement dans la classe
    protected $ville;   // Accessible dans la classe et enfants
}

Méthodes :

class Personne {
    public function saluer() {
        return "Bonjour";
    }
    
    private function calculerAge() {
        // Méthode privée
    }
}

Accès avec $this :

class Personne {
    public $nom;
    
    public function afficherNom() {
        echo $this->nom;  // $this référence l'instance
    }
}

Constructeur

Le constructeur est appelé automatiquement à la création de l'objet.

Constructeur classique :

class Personne {
    public $nom;
    public $age;
    
    public function __construct($nom, $age) {
        $this->nom = $nom;
        $this->age = $age;
    }
}

$jean = new Personne("Jean", 30);

Promotion des propriétés (PHP 8.0+) :

class Personne {
    public function __construct(
        public string $nom,
        public int $age
    ) {}
}

// Équivalent à :
class Personne {
    public string $nom;
    public int $age;
    
    public function __construct(string $nom, int $age) {
        $this->nom = $nom;
        $this->age = $age;
    }
}

Destructeur :

public function __destruct() {
    // Code exécuté quand l'objet est détruit
}

Visibilité

public : Accessible partout

public $nom;
public function afficher() {}

private : Accessible seulement dans la classe

private $age;
private function calculer() {}

protected : Accessible dans la classe et classes enfants

protected $ville;
protected function modifier() {}

Getters et Setters :

class Personne {
    private $age;
    
    public function getAge(): int {
        return $this->age;
    }
    
    public function setAge(int $age): void {
        if ($age > 0) {
            $this->age = $age;
        }
    }
}

Héritage

Une classe peut hériter d'une autre classe.

Syntaxe :

class Etudiant extends Personne {
    public $ecole;
    
    public function __construct($nom, $age, $ecole) {
        parent::__construct($nom, $age);
        $this->ecole = $ecole;
    }
    
    public function etudier() {
        return $this->nom . " étudie à " . $this->ecole;
    }
}

parent:: Appelle la méthode de la classe parente

public function saluer() {
    $message = parent::saluer();
    return $message . " et je suis étudiant";
}

Override : Redéfinir une méthode parente

class Etudiant extends Personne {
    public function saluer() {
        return "Salut, je suis " . $this->nom;
    }
}

Interfaces

Une interface définit un contrat que les classes doivent respecter.

Définition :

interface Affichable {
    public function afficher(): string;
}

Implémentation :

class Personne implements Affichable {
    public function afficher(): string {
        return $this->nom;
    }
}

Plusieurs interfaces :

interface Affichable {
    public function afficher(): string;
}

interface Sauvegardable {
    public function sauvegarder(): bool;
}

class Personne implements Affichable, Sauvegardable {
    // Doit implémenter les deux interfaces
}

Traits

Les traits permettent de réutiliser du code entre classes.

Définition :

trait Loggable {
    public function log($message) {
        echo "Log: " . $message;
    }
}

Utilisation :

class Personne {
    use Loggable;
    
    public function creer() {
        $this->log("Personne créée");
    }
}

Plusieurs traits :

class MaClasse {
    use Trait1, Trait2, Trait3;
}

Résolution de conflits :

trait A {
    public function test() {
        echo "A";
    }
}

trait B {
    public function test() {
        echo "B";
    }
}

class C {
    use A, B {
        A::test insteadof B;  // Utilise A::test
        B::test as testB;     // Renomme B::test en testB
    }
}

Namespace

Les namespaces organisent le code et évitent les conflits de noms.

Déclaration :

namespace MonProjet\Models;

class Personne {
    // ...
}

Utilisation :

use MonProjet\Models\Personne;

$p = new Personne();

Alias :

use MonProjet\Models\Personne as User;

$p = new User();

Namespace global :

$p = new \MonProjet\Models\Personne();

Méthodes magiques

__get et __set :

class Personne {
    private $data = [];
    
    public function __get($name) {
        return $this->data[$name] ?? null;
    }
    
    public function __set($name, $value) {
        $this->data[$name] = $value;
    }
}

$p = new Personne();
$p->nom = "Jean";  // Appelle __set
echo $p->nom;      // Appelle __get

__toString :

public function __toString(): string {
    return $this->nom . " a " . $this->age . " ans";
}

echo $p;  // Affiche la représentation string

__call et __callStatic :

public function __call($name, $arguments) {
    // Appelé quand méthode n'existe pas
}

public static function __callStatic($name, $arguments) {
    // Pour méthodes statiques
}

Exercice

Classes de base
- Créez une classe Personne
- Ajoutez propriétés et méthodes
- Créez des objets et testez
Visibilité
- Créez des propriétés public, private, protected
- Testez l'accès depuis différentes contextes
- Créez des getters/setters
Héritage
- Créez une classe parente
- Créez une classe enfant qui hérite
- Testez parent:: et override
Interfaces
- Créez une interface
- Implémentez-la dans une classe
- Testez le polymorphisme
Traits
- Créez un trait réutilisable
- Utilisez-le dans plusieurs classes
- Testez la résolution de conflits

Quiz

Comment accède-t-on à une propriété dans une méthode ?
- $nom
- $this->nom
- self->nom
Quelle visibilité permet l'accès dans les classes enfants ?
- private
- protected
- public seulement
Que fait parent:: ?
- Crée un parent
- Appelle la méthode de la classe parente
- Supprime le parent
Que sont les traits ?
- Des classes
- Du code réutilisable entre classes
- Des interfaces
À quoi servent les namespaces ?
- À améliorer les performances
- À organiser le code et éviter les conflits
- À compiler le code

Mini défi

Mission : Créer un système POO complet

Créez un système de gestion de bibliothèque avec POO :

Structure :

Interface Empruntable
- emprunter() : bool
- retourner() : bool
- estDisponible() : bool
Classe Livre
- Propriétés : isbn, titre, auteur, annee
- Implémente Empruntable
- Méthodes : afficher(), emprunter(), retourner()
Classe DVD (hérite de Livre ou implémente Empruntable)
- Propriétés supplémentaires : duree
- Méthodes spécifiques
Trait Loggable
- Méthode log() pour enregistrer les actions
Classe Bibliotheque
- Collection de Livres/DVDs
- Méthodes : ajouter(), rechercher(), emprunter(), retourner()
- Utilise le trait Loggable

Critères :

✅ Utilisation de classes, interfaces, traits
✅ Héritage approprié
✅ Visibilité correcte (encapsulation)
✅ Namespace pour organiser
✅ Code bien structuré et documenté

Objectif : Maîtriser la POO complète en PHP et créer une architecture propre.

Validation : Vous pouvez passer au module suivant quand vous maîtrisez classes, héritage, interfaces, traits et namespaces.

Objectif​

Théorie​

Classes & objets​

Propriétés & méthodes​

Constructeur​

Visibilité​

Héritage​

Interfaces​

Traits​

Namespace​

Méthodes magiques​

Exercice​

Quiz​

Mini défi​