Encapsulation et héritage : Programmation orienté objet PHP

Dans ce chapitre, nous allons découvrir les concepts d’encapsulation et d’héritage en programmation orientée objet, ou POO, en PHP.

L’encapsulation en programmation orientée objet en PHP

L’encapsulation est une pratique fondamentale qui consiste à regrouper les données et les méthodes qui les manipulent au sein d’une même entité : l’objet. Cela permet de protéger les données et de limiter leur accès afin de garantir l’intégrité et la sécurité du programme.

Compréhension de l’encapsulation

L’encapsulation vise à cacher les détails d’implémentation à l’extérieur de l’objet et à fournir une interface claire et cohérente pour interagir avec lui. En regroupant les propriétés et les méthodes qui les manipulent au sein de l’objet, l’encapsulation permet de contrôler comment ces données sont utilisées et modifiées, ce qui facilite la maintenance et l’évolution du code.

Mise en pratique de l’encapsulation en PHP

En PHP, l’encapsulation est souvent mise en œuvre en définissant la visibilité des propriétés et des méthodes à l’intérieur de la classe. Les trois niveaux de visibilité les plus couramment utilisés sont :

• Public : Les propriétés et les méthodes publiques sont accessibles depuis n’importe où, à l’intérieur ou à l’extérieur de la classe.
• Protected : Les propriétés et les méthodes protégées sont accessibles uniquement depuis la classe elle-même et les classes héritières.
• Private : Les propriétés et les méthodes privées ne sont accessibles qu’à l’intérieur de la classe où elles sont définies.

class MaClasse {
    public $publicProp = "Propriété publique";
    protected $protectedProp = "Propriété protégée";
    private $privateProp = "Propriété privée";

}

// Instanciation de la classe
$objet = new MaClasse();

// Accès aux propriétés
echo $objet->publicProp . "
"; // Accès autorisé
//echo $objet->protectedProp . "
"; // Erreur fatale : accès protégé
//echo $objet->privateProp . "
"; // Erreur fatale : accès privé

En définissant la visibilité appropriée pour les membres de la classe, vous pouvez contrôler l’accès à ces membres depuis l’extérieur de la classe, garantissant ainsi une encapsulation efficace.

Avantages de l’encapsulation

L’encapsulation présente plusieurs avantages, notamment :

La protection des données car en limitant l’accès direct aux données, vous pouvez éviter les modifications non autorisées et garantir l’intégrité des données. En regroupant les fonctionnalités liées ensemble dans des objets encapsulés, vous favorisez la modularité et la réutilisabilité du code. En cachant les détails d’implémentation derrière une interface claire et cohérente, l’encapsulation rend le code plus facile à comprendre, à modifier et à maintenir.

Héritage en programmation orientée objet en PHP

L’héritage est un mécanisme fondamental qui permet à une classe d’hériter des propriétés et des méthodes d’une autre classe, appelée classe parente ou classe de base. Cela permet de réutiliser le code existant, de favoriser la modularité et d’organiser les classes de manière hiérarchique.

Comprendre l’héritage

L’héritage permet à une classe enfant de bénéficier des propriétés et des méthodes définies dans sa classe parente, tout en lui permettant de définir ses propres fonctionnalités supplémentaires. Cela favorise la réutilisabilité du code en évitant la duplication et en encourageant la création de relations logiques entre les classes.

Mise en pratique de l’héritage en PHP

En PHP, l’héritage est mis en œuvre à l’aide du mot-clé extends. Par exemple, supposons que nous ayons une classe parente Vehicule :

class Vehicule {
    public function demarrer() {
        echo "Le véhicule démarre.";
    }
}

Nous pouvons créer la classe enfant Voiture qui hérite de la classe parente Vehicule :

class Voiture extends Vehicule {
    // Cette classe hérite automatiquement de la méthode demarrer() de la classe parente Vehicule
}

Maintenant, la classe Voiture hérite de la méthode demarrer() de la classe parente Vehicule et peut également définir ses propres méthodes et propriétés supplémentaires si nécessaire. Nous pourrions, par exemple, créer les classes Moto ou Camion qui elles aussi hériteraient de Vehicule. La fonction demarrer() leur étant commune, cela évite la duplication de code.

Voici un autre exemple d’héritage en PHP avec une classe parente Animal et deux classes enfants Chien et Chat :

class Animal {
    protected $nom;

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

    public function parler() {
        echo "L'animal parle.";
    }
}

class Chien extends Animal {
    public function aboyer() {
        echo "Le chien ".$this->nom." aboie.";
    }
}

class Chat extends Animal {
    public function miauler() {
        echo "Le chat ".$this->nom." miaule.";
    }
}

// Création d'objets
$chien = new Chien("Max");
$chat = new Chat("Minou");

// Appels de méthodes
$chien->parler(); // La méthode parler() est héritée de la classe parente Animal
// Cela affichera : L'animal parle.
echo "<br>";
$chien->aboyer(); // La méthode aboyer() est spécifique à la classe Chien
// Cela affichera : Le chien Max aboie.
echo "<br>";
$chat->parler(); // La méthode parler() est héritée de la classe parente Animal
// Cela affichera : L'animal parle.
echo "<br>";
$chat->miauler(); // La méthode miauler() est spécifique à la classe Chat
// Cela affichera : Le chat Minou miaule.

• La classe Animal est la classe parente qui définit les caractéristiques générales des animaux, avec une propriété nom et une méthode parler().
• Les classes Chien et Chat sont les classes enfants qui héritent de la classe parente Animal.
• Chacune des classes enfants a ses propres méthodes spécifiques : aboyer() pour la classe Chien et miauler() pour la classe Chat.

Lorsque nous créons des objets de ces classes et appelons leurs méthodes, nous pouvons voir comment l’héritage fonctionne : les méthodes définies dans la classe parente sont accessibles par les classes enfants, et les classes enfants peuvent également avoir leurs propres méthodes spécifiques.

Pourquoi utiliser le mot-clé $this ?

Lorsque vous créez une classe en PHP dans le cadre de la programmation orientée objet, vous créez une sorte de modèle ou de plan pour des objets spécifiques. Imaginez-le comme une recette pour créer des objets. Maintenant, $this est un mot-clé spécial que vous utilisez à l’intérieur de cette classe pour faire référence à l’objet lui-même une fois qu’il est créé.

class Animal {
    protected $nom;

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

    public function parler() {
        echo "L'animal parle.";
    }
}

Dans notre exemple, nous avons une classe Animal qui possède une propriété protégée (protected) appelée $nom. La visibilité protected signifie que cette propriété peut être accédée à l’intérieur de la classe elle-même et à l’intérieur des classes enfants qui héritent de cette classe.

Dans le constructeur de la classe, qui est une méthode spéciale appelée __construct, un paramètre $nom est passé pour initialiser la propriété $nom de l’objet créé.

Dans cette classe, nous utilisons donc $this dans le constructeur pour faire référence à l’objet actuel qui est en train d’être créé. Plus précisément, dans la ligne :

$this->nom = $nom;

$this fait référence à l’objet de la classe Animal qui est actuellement en cours de construction, et ->nom fait référence à la propriété $nom de cet objet. Donc, $this->nom signifie la propriété nom de cet objet actuel.

L’utilisation de $this est nécessaire dans ce contexte pour distinguer la variable locale $nom (qui est le paramètre de la méthode __construct) de la propriété $nom de l’objet. Sans $this, PHP considérerait simplement nom comme une nouvelle variable locale dans le constructeur et ne mettrait pas à jour la propriété de l’objet.

$this est utilisé dans cette classe pour référencer l’objet actuel et accéder à ses propriétés et méthodes. C’est une façon pour PHP de savoir que vous faites référence à des éléments spécifiques de l’objet en cours d’utilisation.

Avantages de l’héritage

L’héritage présente plusieurs avantages, notamment :

L’héritage permet de réutiliser le code existant en le partageant entre les classes apparentées, ce qui évite la duplication et favorise la modularité. Les classes enfants peuvent étendre ou spécialiser les fonctionnalités de leur classe parente en ajoutant de nouvelles méthodes ou en redéfinissant les méthodes existantes.

L’héritage permet également d’organiser les classes de manière hiérarchique, ce qui facilite la compréhension et la maintenance du code.

Dans le prochain chapitre, nous explorerons le concept de polymorphisme, qui permet à des objets de différentes classes de répondre de manière cohérente aux mêmes messages ou appels de méthodes.