Sommaire

La programmation orientée objet en PHP.

Introduction à la programmation orientée objet.

Qu'est-ce que la programmation orientée objet ?

La Programmation Orientée Objet aussi appelée POO est un paradigme de programmation qui utilise des objets et des classes pour structurer le code de manière modulaire et réutilisable. Une classe est un modèle définissant les propriétés et les comportements (méthodes) que les objets créés à partir de cette classe posséderont. Un objet est une instance concrète de cette classe.

En POO, les données et les fonctions sont regroupées en unités appelées objets, permettant une meilleure organisation et une gestion plus facile des projets de développement complexes.

Avantages de la POO.

La POO offre plusieurs avantages significatifs pour le développement de logiciels:

  1. Modularité : La POO permet de diviser un programme en unités plus petites et plus gérables appelées classes. Chaque classe représente un concept ou une entité distincte, ce qui facilite la compréhension et la maintenance du code.
  2. Réutilisabilité : Les classes peuvent être réutilisées dans différents programmes ou projets. Une fois qu'une classe est écrite et testée, elle peut être utilisée comme un bloc de construction pour d'autres applications, ce qui réduit le temps de développement et améliore la fiabilité.
  3. Encapsulation : La POO permet de regrouper les données et les méthodes qui les manipulent au sein d'une même classe. Cela protège les données contre les accès non autorisés et les modifications accidentelles, et permet de contrôler l'accès aux données via des méthodes spécifiques (getters et setters).
  4. Héritage : L'héritage permet de créer de nouvelles classes basées sur des classes existantes. Cela favorise la réutilisation du code et permet de créer des hiérarchies de classes qui partagent des propriétés et des comportements communs.
  5. Polymorphisme : Le polymorphisme permet de traiter les objets de différentes classes de manière uniforme. Cela signifie qu'une seule interface peut être utilisée pour représenter des objets de différentes classes, ce qui simplifie le code et améliore sa flexibilité.
  6. Maintenance facilitée : Grâce à la modularité et à l'encapsulation, la POO facilite la maintenance et la mise à jour du code. Les modifications apportées à une classe n'affectent pas les autres classes, ce qui réduit les risques d'erreurs et de bugs.
  7. Extensibilité : La POO permet d'ajouter de nouvelles fonctionnalités à un programme sans modifier le code existant. Les nouvelles classes peuvent être créées pour étendre les fonctionnalités des classes existantes, ce qui rend le programme plus flexible et évolutif.

Les classes et les objets.

En POO, une classe est un modèle ou un plan qui définit les propriétés et les comportements que les objets créés à partir de cette classe posséderont. Pensez à une classe comme à une recette de cuisine : elle décrit les ingrédients (propriétés) et les étapes de préparation (méthodes) nécessaires pour créer un plat.

Un objet, quant à lui, est une instance concrète de cette classe. C'est le résultat de l'application de la recette. Chaque objet créé à partir de la même classe peut avoir des valeurs différentes pour ses propriétés, mais il partage la même structure et les mêmes comportements définis par la classe.

En résumé, une classe est une définition abstraite, tandis qu'un objet est une réalisation concrète de cette définition. La classe sert de plan pour créer des objets, et les objets sont les instances spécifiques qui existent dans le programme.

Déclaration de classes en PHP.

En PHP, une classe est déclarée à l'aide du mot-clé class suivi du nom de la classe. Voici un exemple de déclaration de classe :

<?php

class Livre {
    }
}

Instanciation d'objets.

Pour créer une instance d'une classe, on utilise le mot-clé new suivi du nom de la classe. Voici un exemple d'instanciation d'un objet :

<?php

$monLivre = new Livre();
$monLivre->afficherDetails();

Propriétés et méthodes

Les propriétés sont des variables définies au sein d'une classe. Elles représentent les caractéristiques ou les attributs d'un objet. Par exemple, dans une classe Livre, les propriétés pourraient inclure le titre et l'auteur du livre.

<?php

class Livre {
    public $titre;
    public $auteur;
}

Les méthodes sont des fonctions définies au sein d'une classe. Elles représentent les comportements ou les actions que les objets de cette classe peuvent effectuer. Par exemple, une méthode dans une classe Livre pourrait être afficherDetails, qui affiche les détails du livre.

<?php

class Livre {
    public $titre;
    public $auteur;

    public function afficherDetails() {
        echo "Vous lisez le livre intitulé '{$this->titre}' écrit par {$this->auteur}.";
    }
}

Les propriétés et les méthodes peuvent avoir différents niveaux de visibilité : public, protected et private. La visibilité détermine l'accessibilité des propriétés et des méthodes depuis l'extérieur de la classe.

Encapsulation.

L'encapsulation consiste à regrouper les données (propriétés) et les méthodes qui manipulent ces données au sein d'une même unité appelée classe. Cela permet de protéger les données contre les accès non autorisés et les modifications accidentelles, et de contrôler l'accès aux données via des méthodes spécifiques (getters et setters).

Encapsulation des propriétés avec les modificateurs d'accès.

Les modificateurs d'accès public, protected et private déterminent la visibilité des propriétés et des méthodes d'une classe. Voici une brève description de chaque modificateur :

Utilisation des méthodes «getter» et «setter».

Les méthodes «getter» et «setter» permettent d'accéder et de modifier les propriétés privées d'une classe. Elles sont utilisées pour contrôler l'accès aux données et garantir leur intégrité. Voici un exemple d'utilisation des méthodes getter et setter :

<?php

class Livre {
    private $titre;
    private $auteur;

    public function getTitre() {
        return $this->titre;
    }

    public function setTitre($titre) {
        $this->titre = $titre;
    }

    public function getAuteur() {
        return $this->auteur;
    }

    public function setAuteur($auteur) {
        $this->auteur = $auteur;
    }
}

Héritage.

L'héritage est un mécanisme de la POO qui permet à une classe d'hériter des propriétés et des méthodes d'une autre classe. Cela favorise la réutilisation du code et permet de créer des hiérarchies de classes qui partagent des propriétés et des comportements communs.

Héritage de classes en PHP.

En PHP, l'héritage est implémenté à l'aide du mot-clé extends. La classe qui hérite est appelée classe enfant (ou sous-classe), et la classe dont elle hérite est appelée classe parent (ou super-classe). Voici un exemple d'héritage de classes en PHP :

<?php

class Livre {
    public $titre;
    public $auteur;

    public function afficherDetails() {
        echo "Vous lisez le livre intitulé '{$this->titre}' écrit par {$this->auteur}.";
    }
}

class Roman extends Livre {
    public $genre;

    public function afficherGenre() {
        echo "Ce roman appartient au genre '{$this->genre}'.";
    }
}

$monRoman = new Roman();
$monRoman->titre = "1984";
$monRoman->auteur = "George Orwell";
$monRoman->genre = "Dystopie";
$monRoman->afficherDetails();
$monRoman->afficherGenre();

Utilisation du mot-clé extends.

Le mot-clé extends est utilisé pour indiquer qu'une classe hérite d'une autre classe. La classe enfant hérite de toutes les propriétés et méthodes de la classe parent, ce qui permet de réutiliser le code existant et d'ajouter de nouvelles fonctionnalités spécifiques à la classe enfant.

<?php

class Livre {
    public function afficherDetails() {
        echo "Vous lisez un livre.";
    }
}

class Roman extends Livre {
    public function afficherDetails() {
        echo "Vous lisez un roman.";
    }
}

$monRoman = new Roman();
$monRoman->afficherDetails();

Surcharge de méthodes

La surcharge de méthodes permet à une classe enfant de redéfinir une méthode héritée de la classe parent. Cela permet de personnaliser le comportement de la méthode dans la classe enfant. Voici un exemple de surcharge de méthode :

<?php

class Livre {
    public function afficherDetails() {
        echo "Vous lisez un livre.";
    }
}

class Roman extends Livre {
    public function afficherDetails() {
        echo "Vous lisez un roman.";
    }
}

$monRoman = new Roman();
$monRoman->afficherDetails();

Polymorphisme.

Le polymorphisme est un concept en POO qui permet d'utiliser une même méthode ou interface pour manipuler différents types d'objets. Cela rend le code plus flexible et maintenable, en permettant une gestion uniforme des objets ayant des comportements spécifiques.

En PHP, le polymorphisme peut être mis en œuvre à l'aide des interfaces, des classes abstraites, et de la redéfinition de méthodes dans les classes enfants.

Utilisation des interfaces

Les interfaces définissent un contrat que les classes doivent respecter en implémentant les méthodes déclarées. Voici un exemple basé sur l'interface Livre :

<?php

interface Livre {
    public function afficherDetails();
}

class Roman implements Livre {
    private $titre;
    private $auteur;
    private $genre;

    public function __construct($titre, $auteur, $genre) {
        $this->titre = $titre;
        $this->auteur = $auteur;
        $this->genre = $genre;
    }

    public function afficherDetails() {
        echo "Le roman '{$this->titre}' écrit par {$this->auteur} appartient au genre {$this->genre}.";
    }
}

class Magazine implements Livre {
    private $titre;
    private $editeur;

    public function __construct($titre, $editeur) {
        $this->titre = $titre;
        $this->editeur = $editeur;
    }

    public function afficherDetails() {
        echo "Le magazine '{$this->titre}' est publié par {$this->editeur}.";
    }
}

function afficherLivre(Livre $livre) {
    $livre->afficherDetails();
}

$roman = new Roman("1984", "George Orwell", "Dystopie");
$magazine = new Magazine("Science & Vie", "Mondadori France");

afficherLivre($roman);    // Le roman '1984' écrit par George Orwell appartient au genre Dystopie.
afficherLivre($magazine); // Le magazine 'Science & Vie' est publié par Mondadori France.

Utilisation des classes abstraites

Les classes abstraites peuvent contenir des méthodes abstraites (sans implémentation) ainsi que des méthodes concrètes (avec implémentation). Voici un exemple basé sur une classe abstraite Livre :

<?php

abstract class Livre {
    protected $titre;
    protected $auteur;

    public function __construct($titre, $auteur) {
        $this->titre = $titre;
        $this->auteur = $auteur;
    }

    abstract public function afficherDetails();
}

class Roman extends Livre {
    private $genre;

    public function __construct($titre, $auteur, $genre) {
        parent::__construct($titre, $auteur);
        $this->genre = $genre;
    }

    public function afficherDetails() {
        echo "Le roman '{$this->titre}' écrit par {$this->auteur} appartient au genre {$this->genre}.";
    }
}

class Encyclopedie extends Livre {
    private $volume;

    public function __construct($titre, $auteur, $volume) {
        parent::__construct($titre, $auteur);
        $this->volume = $volume;
    }

    public function afficherDetails() {
        echo "L'encyclopédie '{$this->titre}' écrite par {$this->auteur} est au volume {$this->volume}.";
    }
}

function afficherLivre(Livre $livre) {
    $livre->afficherDetails();
}

$roman = new Roman("Les Misérables", "Victor Hugo", "Classique");
$encyclopedie = new Encyclopedie("Encyclopædia Britannica", "Divers auteurs", "15");

afficherLivre($roman);         // Le roman 'Les Misérables' écrit par Victor Hugo appartient au genre Classique.
afficherLivre($encyclopedie);  // L'encyclopédie 'Encyclopædia Britannica' écrite par Divers auteurs est au volume 15.

Héritage et redéfinition de méthodes.

Les classes enfants peuvent redéfinir les méthodes héritées des classes parentes pour personnaliser leur comportement. Voici un exemple de redéfinition de méthodes avec Livre :

<?php

class Livre {
    protected $titre;

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

    public function afficherDetails() {
        echo "Détails du livre : {$this->titre}.";
    }
}

class Roman extends Livre {
    public function afficherDetails() {
        echo "Détails du roman : {$this->titre}.";
    }
}

class Magazine extends Livre {
    public function afficherDetails() {
        echo "Détails du magazine : {$this->titre}.";
    }
}

function afficherLivre(Livre $livre) {
    $livre->afficherDetails();
}

$roman = new Roman("Germinal");
$magazine = new Magazine("National Geographic");

afficherLivre($roman);    // Détails du roman : Germinal.
afficherLivre($magazine); // Détails du magazine : National Geographic.

Ces exemples démontrent comment le polymorphisme permet d'utiliser des interfaces ou des classes communes tout en offrant la possibilité de personnaliser les comportements pour des types d'objets spécifiques. Cela favorise une architecture logicielle flexible et maintenable.

Les méthodes magiques en PHP.

Les méthodes magiques en PHP sont des méthodes spéciales qui commencent par un double underscore (__) et offrent des fonctionnalités spécifiques ou personnalisées lorsqu'elles sont définies dans une classe. Ces méthodes sont déclenchées automatiquement par le moteur PHP dans certains contextes, ce qui permet de simplifier certaines tâches ou de personnaliser le comportement des objets.

Pour consulter la liste complète des méthodes magiques, vous pouvez vous référer à la documentation officielle de PHP https://www.php.net/manual/fr/language.oop5.magic.php.

Principales méthodes magiques.

  1. __construct et __destruct : Utilisées pour initialiser ou nettoyer un objet lors de sa création ou de sa destruction.

    <?php

class Livre {
   public function __construct($titre) {
       echo "Le livre '{$titre}' a été créé.";
   }

   public function __destruct() {
       echo "L'objet livre est détruit.";
   }
}

$livre = new Livre("1984");
unset($livre);

  2. __get et __set : Permettent d'accéder ou de modifier des propriétés non accessibles ou inexistantes.

    <?php

class Livre {
   private $donnees = [];

   public function __get($nom) {
       return $this->donnees[$nom] ?? "Propriété '{$nom}' inexistante.";
   }

   public function __set($nom, $valeur) {
       $this->donnees[$nom] = $valeur;
   }
}

$livre = new Livre();
$livre->auteur = "George Orwell";
echo $livre->auteur; // George Orwell

  3. __call et __callStatic : Déclenchées lorsqu'une méthode inaccessible ou inexistante est appelée sur un objet ou statiquement.

    <?php

class Livre {
   public function __call($nom, $arguments) {
       echo "La méthode '{$nom}' n'existe pas, arguments : " . implode(', ', $arguments);
   }
}

$livre = new Livre();
$livre->afficher("Détails", "supplémentaires");

  4. __toString : Définie pour convertir un objet en chaîne de caractères.

    <?php

class Livre {
   private $titre;

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

   public function __toString() {
       return "Livre : {$this->titre}";
   }
}

$livre = new Livre("1984");
echo $livre; // Livre : 1984

  5. __invoke : Permet de traiter un objet comme une fonction.

    <?php

class Livre {
   public function __invoke($titre) {
       echo "Le livre appelé est '{$titre}'.";
   }
}

$livre = new Livre();
$livre("1984");

Sommaire