Programmation orientée objet

Sommaire

1. Les concepts de base
2. Encapsulation
3. Implémentation en PHP
4. Implémentation en Python
5. Le piège de la référence

Les concepts de base de la POO, illustrés par la même classe implémentée en PHP et en Python.

1. Les concepts de base

Terme	Définition
Classe	Modèle décrivant une catégorie d'objets : ses attributs et ses méthodes
Objet (instance)	Exemplaire concret d'une classe, avec ses propres valeurs d'attributs
Attribut	Donnée caractérisant l'objet
Méthode	Comportement, opération que l'objet sait effectuer
Constructeur	Méthode particulière appelée à la création de l'objet, qui initialise ses attributs
Accesseurs (getters / setters)	Méthodes qui donnent un accès contrôlé aux attributs privés

2. Encapsulation

L'encapsulation consiste à masquer l'état interne de l'objet et à n'exposer que ce qui est nécessaire.

Visibilité	Accessible depuis
`public`	N'importe où
`protected`	La classe et ses classes filles
`private`	La classe elle-même uniquement

Règle de conception : attributs privés, méthodes publiques. L'intérêt n'est pas de « cacher » par principe, mais de garder la main sur les modifications. Un setter peut valider la donnée, journaliser le changement ou déclencher un recalcul — ce qu'un attribut public ne permet pas.

Une méthode peut aussi être privée quand elle ne sert qu'en interne : ConcatPrenomNom() ci-dessous est un détail d'implémentation appelé uniquement par AfficherInfos().

3. Implémentation en PHP

Employe.php

<?php
class Employe
{
    // Attributs
    private $numero;
    private $nom;
    private $prenom;
    private $mail;

    // Constructeur
    public function __construct($unNumero, $unNom, $unPrenom, $unMail) {
        $this->numero = $unNumero;
        $this->nom    = $unNom;
        $this->prenom = $unPrenom;
        $this->mail   = $unMail;
    }

    // Méthode privée : usage interne uniquement
    private function ConcatPrenomNom() {
        $initiale = strtoupper($this->prenom[0]);
        return $initiale . "." . $this->nom;
    }

    public function AfficherInfos() {
        echo 'Employé N°' . $this->numero . " = " . $this->ConcatPrenomNom() . '<br>';
    }

    public function GetNom() {
        return $this->nom;
    }

    public function SetNom($unNom) {
        $this->nom = $unNom;
    }
}
?>

Tests.php

<?php
require('Employe.php');

$emp1 = new Employe(1, "Dupont", "john", "johndupont@gmail.com");
$emp1->AfficherInfos();          // Employé N°1 = J.Dupont

$emp1->SetNom("Durand");
$emp1->AfficherInfos();          // Employé N°1 = J.Durand
?>

$this désigne l'objet courant ; l'accès aux membres se fait avec ->.
new instancie la classe et déclenche __construct().

4. Implémentation en Python

class Employe:
    # constructeur
    def __init__(self, unNumero, unNom, unPrenom, unMail):
        self.__numero = unNumero
        self.__nom    = unNom
        self.__prenom = unPrenom
        self.__mail   = unMail

    # méthode privée
    def __concatPrenomNom(self):
        initiale = self.__prenom[0].upper()
        return initiale + "." + self.__nom

    def afficherInfos(self):
        print("Employe N°", self.__numero, " = ", self.__concatPrenomNom())

    def getNom(self):
        return self.__nom

    def setNom(self, unNom):
        self.__nom = unNom


emp1 = Employe(1, "Dupont", "john", "johndupont@gmail.com")
emp1.afficherInfos()
emp1.setNom("Durand")
emp1.afficherInfos()

	PHP	Python
Objet courant	`$this`, implicite	`self`, premier paramètre explicite de chaque méthode
Constructeur	`__construct()`	`__init__()`
Privé	Mot-clé `private`	Double préfixe `__` (name mangling)
Accès	`$obj->methode()`	`obj.methode()`

Nuance importante : en Python, le double underscore ne rend pas l'attribut réellement inaccessible, il le renomme. La visibilité y relève davantage de la convention que de la contrainte du langage, alors qu'en PHP l'accès à un attribut privé depuis l'extérieur provoque une erreur fatale.

5. Le piège de la référence

$emp1 = new Employe(1, "Dupont", "john", "j@mail.com");
$emp2 = $emp1;               // PAS une copie !

$emp2->SetNom("Dupuis");
$emp1->AfficherInfos();      // affiche Dupuis

En PHP comme en Python, une variable objet contient une référence vers l'objet, pas l'objet lui-même. $emp2 = $emp1 fait pointer deux variables vers le même objet en mémoire : modifier l'un modifie l'autre.

$emp3 = new Employe(2, "Martin", "Laurie", "l@mail.com");
$emp3->AfficherInfos();      // Employé N°2 = L.Martin

$emp3 = $emp1;               // emp3 pointe maintenant vers l'objet de emp1
$emp3->AfficherInfos();      // Employé N°1 = J.Dupuis

L'objet Martin n'est plus référencé par personne : il sera détruit par le ramasse-miettes. Pour obtenir une véritable copie indépendante, il faut utiliser clone en PHP ou copy.deepcopy() en Python.