Php initiation aux objets

Présentation de la programmation orienté objet

La programmation orientée objet est une méthode particulière de programmation dont le but est de faciliter la maintenance et la réutilisation de scripts PHP. Elle consiste à formaliser des objets (du monde réel ou non) sous forme d'objets formels informatiques. Cela se fait essentiellement parce qu'on appel une classe, qui regroupe des fonctions et des propriétés pouvant agir sur l'objet ou le caractérisant.

Par exemple, selon ce point de vue on peut modéliser une voiture par une classe "Voiture" qui aura comme propriétés : le nombre de roues, le nombre de portes; et comme fonction : rouler, freiner, accélérer, etc.

Une classe regroupe donc des fonctions et des variables (appelées ici attributs). Les fonctions permettent de modifier des attributs : ainsi par exemple la fonction accélération (un attribut de la classe "voiture") permettra de modifier la vitesse de la voiture en mouvement. Dans cette logique l'on ne peut modifier l'attribut "vitesse" qu'à travers la fonction "accélérer". On appelle ce principe l'encapsulation des données, c'est-à-dire ne pas pouvoir accéder aux données ou aux attributs de l'objet directement mais via des fonctions (appelées ici "méthodes"); chaque attribut disposant donc de droits d'accès à l'extérieur de la classe.

Comment coder une classe en PHP 5

Voici comment une classe peut être codée en PHP 5 :

<?php 
     class Voiture 
     { 
          /** 
          * Déclaration des attributs 
          */ 

          private $vitesse; 
          private $nombre_portes; 
          private $nombre_roues; 

          /** 
          * Cette méthode un peu spéciale est le constructeur, elle est exécutée lorsque vous "créez" votre objet. Elle doit initialiser les attributs de la classe.
          */ 

          public function __construct() 
          { 
               $this->vitesse = 0; 
               $this->nombre_portes = 3; 
               $this->nombre_roues = 4; 
          } 

          /** 
          * Première méthode accessible par tous et modifiant la vitesse de la voiture
          */ 

          public function accelerer($acceleration_moyenne_temps*$temps) 
          { 
               $this->vitesse = $acceleration_moyenne_temps*$temps; 
          }

          /** 
          * Seconde méthode accessible à tous et modifiant le nombre de portes
          */ 

          public function modifier_nb_portes( $nb_portes) 
          { 
               $this->nombre_portes = $nb_portes; 
          } 
     } 
?>

Si on veut créer deux voitures dans ce code. Au lieu toujour modifier les données d'un tableau avec les variables "nombre_portes" ou "vitesse"; avec la programmation orientée objet, on accède à deux objets différents en deux lignes de code; ceci en "instanciant" une classe.

C'est-à-dire qu'à travers ce processus informatique, on crée une version de l'objet ayant des caractéristiques propres. C'est pourquoi la création d'un deuxième objet, le rendra indépendant du premier, bien que tout deux soient instanciés à travers la même classe (même fonctions et mêmes attributs). Ces deux objets aurant des valeurs d'attributs et des valeurs d'entrées différents.

On pourra par exemple avoir une voiture ayant trois portes et la seconde 5 portes; même si rien n'empêche que l'on aie deux voitures parfaitements identiques l'une à côté de l'autre, donc deux objets identifiques au niveau de leurs paramètres.

Voici comment instancier (créer) un objet :

<?php

    $objet_voiture = new Voiture(); 

?>

La variable $objet_voiture représente l'objet qui est ici une voiture et lors de l'éxécution du code, la méthode __construct() de la classe va donc être exécutée exécutée. Les valeurs des attributs "vitesse", "nombre de portes" et "roues", vont donc prendre respectivement les valeurs : "0", "3" et "4". Cependant, comme il s'agit d'une fonction, elle peut prendre elle aussi des paramètres. Tout dépend comment l'on souhaite coder la classe. On pourrait donc très bien avoir une fonction __construct() qui initialiseraot les attributs en fonction des paramètres fournis :

<?php  
     class Voiture  
     {  
          /**  
          * Déclaration des attributs  
          */  

          private $vitesse;  
          private $nombre_portes;  
          private $nombre_roues;  

          /**  
          * Cette méthode un peu spéciale est le constructeur, elle est exécutée lorsque vous "créez" votre objet. Elle doit initialiser les attributs de la classe. 
          */  

          public function __construct($vitesse, $nb_portes, $nb_roues = 4)  
          {  
               $this->vitesse = $vitesse;  
               $this->nombre_portes = $nb_portes;  
               $this->nombre_roues = $nb_roues;  
          }  

          /**  
          * Première méthode accessible par tous et modifiant le niveau de carburant  
          */  

         public function accelerer($acceleration_moyenne_temps*$temps) 
          { 
               $this->vitesse = $acceleration_moyenne_temps*$temps; 
          }

          /**  
          * Seconde méthode accessible à tous et modifiant le nombre de portes 
          */  

          public function modifier_nb_portes($nb_portes)  
          {  
               $this->nombre_portes = $nb_portes;  
          }  
     }  
?>

Lorsque vous créerez l'objet voiture, vous allez pouvoir sans passer par les méthodes appropriées lui fixer un niveau de vitesse (par défaut 0), un nombre de portes (par défaut 3) et un nombre de roues (par défaut 4). Voici deux façons de créer l'objet :

<?php  

$objet_voiture = new Voiture(5, 4); 

//5 : niveau de vitesse et 4 portes, on a pas besoin de spécifier le nombre de roues car il est de 4 par défaut 


$autre_voiture = new Voiture(2, 5, 6); 

//10 : niveau de vitesse, 5 portes et 6 roues 

?>

Il est important de noter que les objets $objet_voiture et $autre_voiture sont deux objets différents ayant leurs propriétés propres.

Les constructeurs et les destructeurs

Les constructeurs et les destructeurs sont des méthodes particulières, qui commencent par deux signes "underscores" accolés et qui sont exécutées à des moments précis.

Comme nous l'avons vu, le constructeur est appelé automatiquement quand on crée un objet; elle sert donc généralement à donner une valeur de départ aux différents attributs de la classe, afin de "construire" l'objet. Cependant cela n'est pas une obligation, car on peut ne rien mettre dans cette méthode.

Le destructeur est appelé à la fin d'exécution de votre script, en voici l'appelation : __destruct().

<?php  
     class Voiture  
     {  
          /**  
          * Déclaration des attributs  
          */  

          private $vitesse;  
          private $nombre_portes;  
          private $nombre_roues;  

          /**  
          * Cette méthode est le constructeur exécutée lors de la création de l'objet. Elle initialise les attributs de la classe. 
          */  

          public function __construct($vitesse, $nb_portes, $nb_roues = 4)  
          {  
               $this->vitesse = $vitesse;  
               $this->nombre_portes = $nb_portes;  
               $this->nombre_roues = $nb_roues;  
          }  

          /**  
          * Destructeur, appelé quand l'objet est détruit
          */  

          public function __destruct()  
          {  
               echo 'L\'objet a été détruit';
          }
     }
?>

Visibilité des propriétés et méthodes

PHP 5 introduit le concept de visibilité de méthodes et d'attributs liés aux droit d'accès. Comme on l'a vu ci-dessus, le principe de l'encapsulation voudrait que les attributs soient uniquement modifiables et accessibles à l'intérieur de la classe, alors que les méthodes devraient l'être par l'extérieur. En pratique, cependant, ce n'est pas toujours le cas.

Les trois instructions permettant de gérer les accès sont :

1) public : on peut avoir accès à la méthode ou à l'attribut demandé à partir de n'importe quel endroit du programme PHP.

2) protected : seule la classe ainsi que ses sous classes éventuelles (classes héritées, voir la suite).

3) private : seule la classe ayant défini l'élément peut y accéder.

Dans notre exemple de la classe Voiture, les attributs n'étant pas modifiables à l'extérieur de la classe, il faut donc passer par les méthodes appropriées.

Pour accéder à un attribut d'une classe, on utilise ce code : $objet->attribut

<?php   
     class Voiture   
     {   
          /**   
          * Déclaration des attributs   
          */   

          private $vitesse;   
          public $nombre_portes;   
          private $nombre_roues; 

          /**   
          * Ici le constructeur          */   

          public function __construct($vitesse, $nb_portes, $nb_roues = 4)   
          {   
               $this->vitesse = $vitesse;   
               $this->nombre_portes = $nb_portes;   
               $this->nombre_roues = $nb_roues;   
          } 
     } 
?>

Maintenant, on passe à l'instanciation de la classe :

<?php 

     $voiture = new Voiture(5, 3); 

     echo $voiture->nombre_portes; //va afficher "3" car l'attribut est en accès public

     echo $voiture->nombre_roues; //Erreur, car on ne peut pas y accéder, l'attribut étant en accès privé
?>

Nota bene : l'on ne met pas de signe $ pour accéder aux attributs d'une classe. Le mot-clé $this désigne la classe courante.

L'héritage

L'héritage consiste à utiliser une classe parente et une ou plusieurs classes filles héritant des propriétés de la classe parente. Dans notre exemple, la classe Voiture peut hériter de certaines propriétés de la classe Vehicule, mais aussi de la classe parente Vehiculemecanique. Le mot utilisé pour dire à PHP qu'une classe hérite d'une autre est le mot-clé extends.

Prenons l'exemple d'une classe Vehicule :

<?php 
   
     class Vehiculemecanique
     {    
          /**    
          * Déclaration des attributs    
          */    

          protected $prix; //On souhaite que les classes qui en héritent puissent y accéder    

          /**    
          * Ici voici le constructeur.   
          */    

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

          /**    
          * Cette méthode permet de modifier le prix du véhicule
          */    

          public function modifier_prix($nouveau_prix)    
          {    
               $this->prix = $nouveau_prix;    
          }  
     }  
?>

Comme vous pouvez le constater, dans la classe Vehiculemecanique il y a tout ce qui est commun commun aux différents véhicules que nous créerons par la suite. Ici, l'attribut "prix", concerne autant une voiture ou une moto qui sont tout deux des biens commerciaux et mécaniques liés aux transports. On met donc tout ce que les véhicules mécaniques ont en commun dans cette même classe parente, qui sera étendue par d'autres classes filles plus spécifiques, comme dans cet exemple :

<?php     
     class Voiture extends Vehiculemecanique
     {     
          /**     
          * Déclaration des attributs     
          */     

          private $climatisation; 

          /**     
          * Constructeur de la classe Voiture 
          */     

          public function __construct($prix_vehicule, $clim)     
          { 
               parent::__construct($prix_vehicule); 

         //On appelle ci-dessus le constructeur de la classe Vehiculemecanique (l'objet parent) en lui fournissant le prix


               $this->climatisation = $clim; 

         //Ici par contre on reste au niveau de la classe Voiture

          }   
     }   
?>

Voici ce que ça donne lors de l'instanciation :

<?php  

     $voiture = new Voiture(17000, TRUE); //On crée une voiture valant 17000 euros et ayant la climatisation 


     $voiture->modifier_prix(15000); 

//On peut modifier le prix de la voiture, car la classe Voiture hérite de la fonction modifier_prix de la classe Vehiculemecanique

?>

Comme vous pouvez le constater, on peut accéder à la classe parente comme si on accédait à la classe Voiture (avec la méthode modifier_prix()), car cette méthode est en accès public; mais si elle était en accès privé, la modification n'aurait pas pu se faire automatiquement. Le niveau de protection le plus restrictif qui permet cette modification est le niveau protected.