POO Avancée - Interfaces et Classes Abstraites

Introduction à la POO avancée

Après avoir maîtrisé les bases de la POO avec les classes, les propriétés et les méthodes, il est temps d'explorer les concepts avancés qui font la puissance de la Programmation Orientée Objet en PHP.

Dans ce module, nous allons découvrir :

• Les interfaces : définir des contrats que les classes doivent respecter
• Les classes abstraites : créer des modèles partiellement implémentés
• Les traits : réutiliser du code dans plusieurs classes
• Les propriétés et méthodes statiques : partager des fonctionnalités entre toutes les instances
• Les classes et méthodes finales : empêcher l'héritage ou la redéfinition
• Les méthodes magiques : intercepter des actions spécifiques sur les objets

Les Interfaces

Une interface définit un contrat qu'une classe doit respecter. Elle contient uniquement des déclarations de méthodes (sans implémentation) que les classes qui l'implémentent doivent définir.

interface Animal {
    public function manger();
    public function seDeplacer();
    public function emettreSon();
}

Caractéristiques des interfaces

• Une interface ne peut contenir que des déclarations de méthodes (sans implémentation)
• Toutes les méthodes d'une interface sont implicitement public
• Une interface peut étendre une ou plusieurs autres interfaces
• Une classe peut implémenter plusieurs interfaces
• Une classe doit implémenter toutes les méthodes définies dans les interfaces qu'elle implémente

interface Mammifere extends Animal {
    public function allaiter();
}

class Chien implements Mammifere {
    private $nom;
    
    public function __construct($nom) {
        $this->nom = $nom;
    }
    
    public function manger() {
        return "{$this->nom} mange des croquettes.";
    }
    
    public function seDeplacer() {
        return "{$this->nom} court sur ses quatre pattes.";
    }
    
    public function emettreSon() {
        return "{$this->nom} aboie : Wouaf !";
    }
    
    public function allaiter() {
        return "Une chienne peut allaiter ses chiots.";
    }
}

Les Classes Abstraites

Une classe abstraite est une classe qui ne peut pas être instanciée directement. Elle sert de modèle pour d'autres classes qui vont l'étendre. Elle peut contenir à la fois des méthodes concrètes (avec implémentation) et des méthodes abstraites (sans implémentation).

abstract class EtreVivant {
    protected $nom;
    protected $age;
    
    public function __construct($nom, $age) {
        $this->nom = $nom;
        $this->age = $age;
    }
    
    // Méthode concrète avec implémentation
    public function getNom() {
        return $this->nom;
    }
    
    // Méthode abstraite sans implémentation
    abstract public function respirer();
}

Caractéristiques des classes abstraites

• Une classe abstraite ne peut pas être instanciée directement
• Elle peut contenir des méthodes concrètes (avec implémentation) et des méthodes abstraites (sans implémentation)
• Les méthodes abstraites doivent être implémentées par les classes qui étendent la classe abstraite
• Une classe abstraite peut implémenter des interfaces
• Une classe ne peut étendre qu'une seule classe abstraite (pas d'héritage multiple en PHP)

class Chien extends EtreVivant {
    private $race;
    
    public function __construct($nom, $age, $race) {
        parent::__construct($nom, $age);
        $this->race = $race;
    }
    
    // Implémentation de la méthode abstraite
    public function respirer() {
        return "{$this->nom} respire par les poumons.";
    }
    
    public function getRace() {
        return $this->race;
    }
}

Interface vs Classe Abstraite

Les interfaces et les classes abstraites servent à des fins similaires mais ont des différences importantes :

EtreVivant (abstract)

# nom: string
# age: int
+ __construct(nom: string, age: int)
+ getNom(): string
+ getAge(): int
+ respirer(): string (abstract)

↑

Chien

- race: string
+ __construct(nom: string, age: int, race: string)
+ respirer(): string
+ getRace(): string

↗

Mammifere

+ manger(): string
+ seDeplacer(): string
+ emettreSon(): string
+ allaiter(): string

Note: Mammifere étend l'interface Animal

Les Traits

Les traits sont un mécanisme permettant la réutilisation de code dans des langages à héritage simple comme PHP. Un trait est similaire à une classe, mais son seul but est de regrouper des fonctionnalités de manière cohérente dans une ou plusieurs classes.

trait Identifiable {
    private $id;
    
    public function genererIdentifiant() {
        $this->id = uniqid(get_class($this) . '_');
    }
    
    public function getId() {
        return $this->id;
    }
}

Utilisation des traits

Pour utiliser un trait dans une classe, on utilise le mot-clé use à l'intérieur de la déclaration de la classe :

class Chien extends EtreVivant implements Mammifere {
    // Utilisation du trait
    use Identifiable;
    
    private $race;
    
    public function __construct($nom, $age, $race) {
        parent::__construct($nom, $age);
        $this->race = $race;
        $this->genererIdentifiant(); // Méthode du trait
    }
    
    // Implémentations des méthodes...
}

Caractéristiques des traits

• Un trait peut contenir des méthodes et des propriétés
• Une classe peut utiliser plusieurs traits
• Les méthodes d'un trait peuvent être abstraites
• Les traits peuvent utiliser d'autres traits
• En cas de conflit de noms, vous pouvez les résoudre avec l'opérateur de résolution insteadof ou les renommer avec as

trait A {
    public function bonjour() {
        return "Bonjour de A!";
    }
}

trait B {
    public function bonjour() {
        return "Bonjour de B!";
    }
    
    public function salut() {
        return "Salut de B!";
    }
}

class C {
    // Résolution de conflits
    use A, B {
        B::bonjour insteadof A; // Utiliser bonjour de B
        A::bonjour as bonjourA; // Renommer bonjour de A
    }
}

Propriétés et Méthodes Statiques

Les propriétés et méthodes statiques appartiennent à la classe elle-même plutôt qu'à une instance spécifique. Elles sont accessibles sans avoir besoin d'instancier la classe.

class Compteur {
    private static $compteur = 0;
    
    public static function incrementer() {
        self::$compteur++;
    }
    
    public static function getValeur() {
        return self::$compteur;
    }
    
    public static function reinitialiser() {
        self::$compteur = 0;
    }
}

echo Compteur::getValeur(); // Affiche 0
Compteur::incrementer();
Compteur::incrementer();
echo Compteur::getValeur(); // Affiche 2
Compteur::reinitialiser();
echo Compteur::getValeur(); // Affiche 0

Caractéristiques des membres statiques

• Ils sont accessibles sans avoir besoin d'instancier la classe (avec l'opérateur de résolution de portée ::)
• Ils sont partagés par toutes les instances de la classe
• Dans les méthodes statiques, $this n'est pas disponible car il n'y a pas d'instance de la classe
• On utilise self:: pour accéder aux membres statiques à l'intérieur de la classe
• On utilise static:: pour la liaison dynamique (résolution à l'exécution)

Classes et Méthodes Finales

Le mot-clé final empêche l'héritage des classes ou la redéfinition des méthodes dans les classes filles.

final class Configuration {
    private static $instance = null;
    private $parametres = [];
    
    private function __construct() {
        $this->parametres = [
            'debug' => true,
            'timezone' => 'Europe/Paris'
        ];
    }
    
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new Configuration();
        }
        return self::$instance;
    }
    
    // Méthodes pour accéder aux paramètres
}

class Base {
    final public function methodeCritique() {
        return "Cette méthode ne peut pas être redéfinie";
    }
    
    public function methodeNormale() {
        return "Cette méthode peut être redéfinie";
    }
}

class Derivee extends Base {
    // Impossible de redéfinir methodeCritique
    
    public function methodeNormale() {
        return "Méthode redéfinie";
    }
}

Méthodes Magiques

PHP fournit un ensemble de méthodes magiques qui sont invoquées automatiquement en réponse à certains événements ou actions sur un objet. Ces méthodes commencent par deux underscore (__).

class Exemple {
    private $donnees = [];
    
    // Appelée lors de la lecture d'une propriété non accessible
    public function __get($nom) {
        if (array_key_exists($nom, $this->donnees)) {
            return $this->donnees[$nom];
        }
        return null;
    }
    
    // Appelée lors de l'écriture dans une propriété non accessible
    public function __set($nom, $valeur) {
        $this->donnees[$nom] = $valeur;
    }
    
    // Appelée lors de la vérification de l'existence d'une propriété
    public function __isset($nom) {
        return isset($this->donnees[$nom]);
    }
    
    // Appelée lors de la suppression d'une propriété
    public function __unset($nom) {
        unset($this->donnees[$nom]);
    }
    
    // Appelée lors de l'appel d'une méthode non accessible
    public function __call($nom, $arguments) {
        echo "Appel de la méthode '$nom' avec les arguments: " 
             . implode(", ", $arguments);
    }
    
    // Appelée lors de l'appel d'une méthode statique non accessible
    public static function __callStatic($nom, $arguments) {
        echo "Appel de la méthode statique '$nom'";
    }
    
    // Appelée lors de la conversion de l'objet en chaîne
    public function __toString() {
        return "Exemple avec " . count($this->donnees) . " propriétés";
    }
    
    // Appelée lors du débogage avec var_dump
    public function __debugInfo() {
        return [
            'info' => "Objet de débogage",
            'donnees_count' => count($this->donnees)
        ];
    }
}

Design Patterns et POO Avancée

Les design patterns (patrons de conception) sont des solutions éprouvées à des problèmes récurrents en conception de logiciel. En combinant les concepts avancés de POO, vous pouvez implémenter ces patterns en PHP.

Exemples de design patterns en PHP

class Singleton {
    private static $instance = null;
    
    private function __construct() { } // Constructeur privé
    private function __clone() { } // Clonage privé
    
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

interface Produit {
    public function operation();
}

class ProduitConcretA implements Produit {
    public function operation() {
        return "Résultat de ProduitConcretA";
    }
}

class ProduitConcretB implements Produit {
    public function operation() {
        return "Résultat de ProduitConcretB";
    }
}

class Fabrique {
    public static function creerProduit($type) {
        if ($type === 'A') {
            return new ProduitConcretA();
        } else if ($type === 'B') {
            return new ProduitConcretB();
        }
        throw new Exception("Type de produit inconnu");
    }
}

Bonnes pratiques en POO avancée

• Principe SOLID : Un ensemble de principes de conception orientée objet
  • Single Responsibility : Une classe ne devrait avoir qu'une seule responsabilité
  • Open/Closed : Ouvert à l'extension, fermé à la modification
  • Liskov Substitution : Les objets d'une classe dérivée devraient pouvoir remplacer des objets de la classe de base
  • Interface Segregation : Les interfaces spécifiques sont préférables aux interfaces génériques
  • Dependency Inversion : Dépendez des abstractions, pas des implémentations concrètes
• Préférez la composition à l'héritage : La composition offre souvent plus de flexibilité
• Limitez la profondeur de l'héritage : Évitez les hiérarchies d'héritage trop profondes
• Utilisez les interfaces pour définir des contrats : Favorisez le couplage faible
• Nommez clairement vos abstractions : Les noms devraient refléter le rôle ou le comportement
• Documentez votre code : Utilisez PHPDoc pour expliciter les attentes et les contrats