Initiation à la POO en PHP

POO est l'acronyme de Programmation Orientée Objet.
La programmation orientée objet (POO) peut intimider certains développeurs débutants.
La POO introduit des concepts abstraits comme les classes, les objets, l'encapsulation, l'héritage et le polymorphisme.
Ces notions peuvent sembler complexes pour les programmeurs débutants ou ceux plus expérimentés mais fidèles à la programmation procédurale.
Cependant, une fois ces concepts maîtrisés, la POO offre de nombreux avantages tels qu'une meilleure organisation du code, une réutilisabilité accrue et une maintenance facilitée.

Terminologie

Il faut bien faire la distinction entre deux notions : classe et objet.

La classe

Une classe est un modèle qui définit les propriétés (attributs) et les comportements (méthodes) que ses objets auront.
Concrétement il faut d'abord créer une classe puis créer des objets (instances) de cette classe.

L'objet

Un objet est une instance de classe. Il possède des valeurs spécifiques pour les propriétés définies dans la classe et peut exécuter les méthodes définies.
L'instanciation consiste à créer des objets à partir d'une classe.

POO - exemple1

Le code du document PHP

...
<h3>Initiation à la POO - exemple 1</h3>
<h4>
<?php 
class Employes 
{
    public $nom;
    public $prenom;

    public function fiche() 
	{
        echo "<br>Nom: " . $this->nom . ", prénom : " . $this->prenom;
    }
} // fin définition classe

// instances de classe
$employe1 = new Employes; 
$employe1->nom = 'Dutronc';
$employe1->prenom = 'Jeanne';

$employe2 = new Employes; 
$employe2->nom = 'Fermon';
$employe2->prenom = 'Olivier';

// présentation des objets
$employe1->fiche();
$employe2->fiche();
?>
</h4>
...

Commentaire du code

création d'une classe nommée ici "Employes"
création d'objets (instanciation) à partir de cette classe et manipulation de ces objets

Première partie

On crée une classe Employes. Le nom d'une classe commence toujours par une lettre majuscule.
À l'intérieur de cette classe on définit les variables et les fonctions de ce modèle. On parle plus précisément de propriétés et de méthodes.
Dans l'exemple ci-dessus on définit deux propriétés : $nom & $prenom et une méthode fiche().

Notez que les propriétés et méthodes sont précédées du terme "public". J'aurai pu utiliser le mot "private".
Toute explication sur le sens de ces termes est prématurée ; la réponse sera apportée plus loin.

Étudions attentivement la méthode fiche().
Notez le terme "function". En effet une méthode est une fonction spécifique à une classe.

Que fait cette fonction ?
Elle affiche après un saut de ligne et avec des légendes la valeur des propriétés $nom & $prenom.
Notez la syntaxe $this->nom ; en JS on aurait écrit "this.nom" (notation pointée).
En PHP le point est réservé à la concaténation donc on utilise la notation fléchée.

Deuxième partie

Maintenant q'une classe est définie, on peut créer des objets à partir de cette classe (on dit aussi créer des instances).
Examinons trois instructions reprises ci-dessous :

$employe1 = new Employes(); 
$employe1->nom = 'Dutronc';
$employe1->prenom = 'Jeanne';

Je crée une instance de la classe Employes que je nomme $employe1
Cet objet est vide (car il n'y a pas de méthode pour le remplir) mais il a une structure. Il faut alors affecter des valeurs à ses différentes propriétés.
On retrouve la notation fléchée spécifique à PHP.

création d'une instance : nomObjet = new NomClasse()
affectation d'une valeur à une propriété : nomObjet->propriété = valeur

Je crée ensuite une deuxième instance de Employes : l'objet $employe2. Puis j'affecte des valeurs aux propriétés.

Nous avons donc deux objets "Employes" (ou deux instances de la classe "Employes").
Nous pouvons maintenant les afficher via la méthode fiche().

$employe1->fiche();
$employe2->fiche();

Le rendu de ce document PHP

POO - exemple 2

La description de la classe est un plus complexe mais en contrepartie l'instanciation sera beaucoup plus simple.

Le code du document PHP

...
<h4>
<?php 
class Employes 
{
    public $nom;
    public $prenom;
 
	function __construct($nom,$prenom)
    {
        $this->nom = $nom;
        $this->prenom = $prenom;
    }
	public function fiche() 
	{
        echo "<br>Nom: " . $this->nom . ", prénom : " . $this->prenom ;
    }
} // fin définition classe

// appel implicite de la méthode construct()
$employe1 = new Employes("Dutronc","Jeanne"); 
$employe2 = new Employes("Fermon","Olivier"); 
$employe3 = new Employes("Macron","Brigitte"); 
$employe4 = new Employes("Roussel","Valérie"); 
$employe5 = new Employes("Faure","Olivier"); 
// affichage objets
$employe3->fiche();
$employe4->fiche();
$employe5->fiche();
?>
</h4>
...

Commentaire du script

Nouveauté par rapport au script précédent est la méthode __construct().
Cette méthode est dite "magique". En ce sens qu'elle est appelée automatiquement lors de la création d'une instance de classe.

Attention le nom des méthodes magiques n'est pas libre : __construct() & __destruct().
Les deux "underscores" sont obligatoires suivis du mot clé "construct" OU "destruct".
N'oubliez pas de passer des paramètres à la fonction __construct().

Lorsque vous créer une instance de classe, PHP recherche la méthode __construct() dans la définition de cette classe. Une seule instruction suffit alors pour créer l'objet avec ses propriétés.

$employe1 = new Employes("Dutronc","Jeanne"); 
$employe2 = new Employes("Fermon","Olivier"); 
...
$employe5 = new Employes("Faure","Olivier");

Donc au prix d'une définition de classe légèrement plus compliquée, l'instanciation est beaucoup plus rapide.

Le rendu du document PHP dans un Iframe

Ça devient tellement simple d'instancier que je ne me gêne pas ; je crée 5 objets.

POO - exemple 3 (encapsulation mal traitée)

Une fois n'est pas coutume, commençons par le rendu.

Le rendu

Un superbe affichage mais aussi un messsage d'erreur :
"Fatal error: Uncaught Error: Cannot access private property Voitures::$modele on line 42".

Le script

class Voitures 
{
    private $marque;
    private $modele;
	private $photo; 
 
	function __construct($marque,$modele,$photo)
    {
        $this->marque = $marque;
        $this->modele = $modele;
		$this->photo = $photo;
    }
	public function fiche() 
	{
        echo "<h4>Marque & modèle : "  . $this->marque . " - "  .$this->modele . '</h4>' ;
		echo "<p><img src = $this->photo class ='centre'  style ='width : 40%;'/>";
		echo "<hr>"; 
    }
} // fin définition classe

// Instanciation 
$ma_voiture = new Voitures('Renault', 'clio 5','clio5.jpg');
$auto_felix = new Voitures('Peugeot', '2008 série2','2008.jpg' ); 
$auto_celine = new Voitures('Citroen','C4','c4.jpg'); 

// affichage objets
$ma_voiture->fiche();
$auto_felix->fiche();
$auto_celine->fiche();

$ma_voiture->modele = 'R5'; // changement de modèle.

Commentaire du script

Avant de proposer un "débuggage" du dernier script, je voudrais revenir sur la méthode fiche().

affiche certaines propriétés de l'objet : marque & modèle
affiche la photo correspondant au modèle avec une mise en forme.

La classe CSS 'centre' centre l'image dans son conteneur avec une largeur de 60%. Ce qui est beaucoup, aussi je corrige en rajoutant la règle en ligne : style ='width : 40%;'

Vous devriez commencer à apprécier la POO. Vous constatez qu'en définissant plusieurs méthodes dans la classe, on simplifie considérablement la programmation en aval.
Ainsi l'instruction $ma_voiture->fiche() équivaut à de nombreuses lignes de code en programmation procédurale.

À propos du bug

La dernière instruction (ligne 42) $ma_voiture->modele = 'R5' génère une erreur.
En lisant le script vous avez noté que les propriétés sont désormais privées ("private"). Donc on ne ne peut plus y accéder directement.
J'ai pratiqué ce qu'on appelle dans le jargon POO l'encapsulation ; c'est à dire que toutes les propriétés sont privées.
Il s'agit d'un dispositif de sécurité afin qu'on ne puisse pas saisir n'importe quoi dans les objets.
Pour mettre à jour un objet il faut alors passer par une méthode de MAJ ; méthode qui dispose de contrôles de saisie.

Le script précédent amélioré

Modification du script

Dans ce script je pratique l'encapsulation et en tire les conséquences ...

Partie description de la classe

Je rajoute une méthode publique : public function maj($new_modele,$new_photo) { $this->modele = htmlentities($new_modele); $this->photo = htmlentities($new_photo); // on suppose que le client reste fidèle à une marque } } // fin définition de la classe Voitures

L'injection éventuelle de code HTML malveillant est neutralisée !
Dans la méthode magique __construct() il faudrait aussi intégrer la fonction htmlentities().

Partie manipulation des objets

Je supprime la dernière instruction et remplace par : $ma_voiture->maj('R5','r5.jpg'); //appel de la méthode de maj echo "<h3>Je suis passé à l'électrique ! </h3>" ; $ma_voiture->fiche();

Le rendu du programme 'débuggé'

Plus de bug !

Bien organiser son code

Le code d'une classe pouvant être long dans la réalité, il est conseillé de créer un fichier PHP qui contient uniquement la définition de la classe.
L'usage partagé par les développeurs PHP est de donner l'extension .class.php aux fichiers contenant les définitions de classes.

Le fichier "membres.class.php"

Il contient la définition de la classe 'Membres'. <?php class Membres { private $nom; private $prenom; private $email; function __construct($nom,$prenom,$email) { $this->nom = $nom; $this->prenom = $prenom; $this->email = $email; } public function fiche() { echo "<h4>Nom & prénom : " . $this->nom . " - " . $this->prenom ; echo "<br>Adresse mail : " . $this->email . "</h4>"; echo "<hr>"; } } // fin définition classe Membres ?>>

Trois propriétés et deux méthodes (dont la méthode magique __construct()).

Le document "membres.php"

Il permet de créer et manipuler les membres de l'association.

Code du document "membres.php"

<?php 
include_once('membres.class.php'); 

$membre1 = new Membres('Dupont','Louis','dupont@free.fr'); 
$membre2 = new Membres('François','Jeanne','francois@free.fr');
$membre3 = new Membres('Melanchon','Jacques','melanchon@free.fr');

$membre1->fiche(); 
$membre2->fiche(); 
$membre3->fiche(); 
?>

Notez l'instruction include_once('membres.class.php').

Le rendu

L'héritage

Dans cette association certains membres sont aussi administrateurs.
Outre les trois propriétés (nom, prenom, email) un administrateur se définit aussi par un téléphone et une photo.

Il serait idiot de partir de zéro pour définir la classe Admin. Il suffit de créer une classe Admin à partir de la classe Membres. On dit que la classe Admin hérite de la classe Membres. La classe Admin est la classe fille et Membres, la classe mère.

Le code du document "admin.php"

<?php 
include_once ('membres.class.php'); 
class Admin extends Membres
{
	private $tel;
	private $photo; 
	// rajout de deux propriétés par rapport à Membres
	
	function __construct($nom,$prenom,$email,$tel,$photo)
    {
        $this->nom = $nom;
        $this->prenom = $prenom;
		$this->email = $email;
		$this->tel = $tel;
		$this->photo = $photo;
	}
	public function presenter() 
	{
        echo "<h4>Nom & prénom : "  . $this->nom . " - "  . $this->prenom ;
		echo "<br>Adresse mail & tel : " . $this->email . " - " . $this->tel . "</h4>"; 
		echo "<img src = $this->photo class ='gauche'  style ='width : 20%;'/>";
		echo "<hr>"; 
    
	}	
} // fin définition classe Admin

$admin1 = new Admin('Mortier', 'henri','mortier@free.fr','0123456789','mortier.jpg');
$admin2 = new Admin('Bertout', 'Pauline','bertout@gmail.com','1234567890','bertout.jpg'); 

$admin1->presenter(); 
$admin2->presenter(); 
?>

Étudiez très attentivement le début du script

Inclusion du fichier "membres.class.php" pour récupérer la définition de la classe "Membres".
class Admin extends Membres : la classe Admin hérite de la classe Membres.
Puis je rajoute deux propriétés par rapport aux trois de la classe "Membres".

la méthode magique __construct()
la méthode presenter()

J'aurai pu construire la méthode __contruct() de la classe "Admin" à partir de celle de la classe "Membres" mais la syntaxe est alors un peu délicate ...

Rendu du document "admin.php"

Un bel affichage des administrateurs.

Polymorphisme

Le polymorphisme en POO permet de traiter des objets de différentes classes de manière uniforme.
Il permet à différentes classes d'implémenter des méthodes portant le même nom mais ayant des comportements spécifiques selon leur contexte.
Une interface (ou classe abstraite) indique le nom de la méthode identique aux différentes classes qui partagent cette interface.

Le script du document PHP

// Interface commune
interface Surface {public function calcul_surface();}

class Rectangle implements Surface 
{
    private $largeur;
    private $hauteur;

    public function __construct($largeur, $hauteur) 
	{
        $this->largeur = $largeur;
        $this->hauteur = $hauteur;
    }

    public function calcul_surface() {return round($this->largeur * $this->hauteur,2); }
}
class Cercle implements Surface 
{
    private $rayon;

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

    public function calcul_surface() {return round(pi() * pow($this->rayon, 2),2); }
}

// Fonction utilisant le polymorphisme
function affiche_surface(Surface $forme) {echo "<br>" . $forme->calcul_surface();}

// Utilisation
$rectangle1 = new Rectangle(5, 10);
$cercle1 = new Cercle(7);
$rectangle2 = new Rectangle(20, 20);
$cercle2 = new Cercle(20);

echo affiche_surface($rectangle1). " est la surface du rectangle "; 
echo affiche_surface($cercle1). " est la surface du cercle "; 
echo affiche_surface($rectangle2). " est la surface du rectangle "; 
echo affiche_surface($cercle2). " est la surface du cercle ";

Analyse du script

interface Surface {public function calcul_surface();} :
Dans chaque classe il y a aura une méthode nommée calcul_surface() ; l'interface entre les classes se nommme ici Surface.

class Rectangle implements Surface :
la classe "rectangle" partage l'interface "Surface".

class Cercle implements Surface :
la classe "Cercle" partage l'interface "Surface".

Dans chacune des deux classes il y a une méthode nommée calcul_surface().

function affiche_surface(Surface $forme) {echo $forme->calcul_surface();} :
la fonction affiche_surface() gère le polymorphisme. Selon la 'forme' de l'objet cette fonction appelle la méthode calcul_surface() de la classe "Rectangle" OU la méthode du même nom de la classe "Cercle".

echo affiche_surface($rectangle1) :
appel de la méthode calcul_surface() de la classe "Rectangle puisqu'il s'agit d'une instance de la classe Rectangle.

echo affiche_surface($cercle1) :
appel de la méthode calcul_surface() de la classe "Cercle" puisqu'il s'agit d'une instance de la classe Cercle.

Traduction

Débuter en programmation web - sommaire

Initiation au HTML & CSS

Initiation à PHP & MYSQL

Débuter en programmation web - recherche

L'auteur : Patrick Darcheville

Initiation à la POO en PHP

Terminologie

La classe

L'objet

POO - exemple1

Le code du document PHP

Commentaire du code

Première partie

Deuxième partie

Le rendu de ce document PHP

POO - exemple 2

Le code du document PHP

Commentaire du script

Le rendu du document PHP dans un Iframe

POO - exemple 3 (encapsulation mal traitée)

Le rendu

Le script

Commentaire du script

À propos du bug

Le script précédent amélioré

Modification du script

Partie description de la classe

Partie manipulation des objets

Le rendu du programme 'débuggé'

Bien organiser son code

Le fichier "membres.class.php"

Le document "membres.php"

Code du document "membres.php"

Le rendu

L'héritage

Le code du document "admin.php"

Étudiez très attentivement le début du script

Rendu du document "admin.php"

Polymorphisme

Le script du document PHP

Analyse du script

Le rendu