oujood.com

Héritage des classes

L'héritage fait partie des principes de la programmation orientée objet, et PHP l'implémente dans son modèle objet. L'héritage affecte les relations entre les classes et les objets.

chercher |

PHP cours tutorial

Héritage

L'héritage fait partie des principes de la programmation orientée objet, et PHP l'implémente dans son modèle objet. L'héritage affecte les relations entre les classes et les objets.

L'héritage en POO est une technique très puissante et extrêmement pratique.

L'héritage consiste à utiliser une classe parente et une ou plusieurs classes filles qui héritent des propriétés et méthodes publiques de la classe parente. Par exemple, nous  avons la classe Vehicule des cours précédents, vous pouvez avoir une classe Voiture qui hérite des propriétés de la classe Vehicule , tout en ajoutant des propriétés qui lui sont propres.

Lorsqu'on dit que la classe Voiture hérite de la classe Vehicule, c'est que la classe Voiture hérite de tous les attributs et méthodes de la classe Vehicule.

 Si l'on déclare des méthodes dans la classe Vehicule, et qu'on crée une instance de la classe Voiture, alors on pourra appeler n'importe quelle méthode public déclarée dans la classe Vehicule, et aussi n’importe quel attribut public.

Créer un héritage

Pour dire à PHP qu'une classe hérite d'une autre, le mot-clé extends est utilisé. Prenons l'exemple de la classe Vehicule que revoici :

Code de « Vehicule.php »:

Exemple :       Copier le code

  <?php
    class Vehicule
    {
      // Attributs(les variables ) sont les suivates
 private $roue = 4 ;
 /* le nombre de roues du véhicule par défaut est 4 */
  private $porte ;
	private $carburant ;
 private $compteur ;
 private $tauxConsomation ;
      // Constantes
      // Méthodes  (les fonctions)
  // constructeur
  public function __construct ($roue, $porte, $carburant, $compteur,$tauxConsomation )
          {
  // Message affiché quand un  objet est créé.
              echo 'Voici le constructeur <br />';
  // initialisation des paramètres.
              $this->roue = $roue;
              $this->porte = $porte;
              $this->carburant = $carburant;
              $this->compteur = $compteur;
              $this->tauxConsomation = $tauxConsomation;
          }
  /* Une méthode qui déplacera le véhicule (modifiera son attribut compteur).*/
  public function deplacer()
          {
           $this->compteur = $this->compteur + 50;
          }
  /* Une méthode qui déplacera le véhicule (modifiera son attribut compteur).*/
  public function consommer()
          {
           $this->carburant = $this->carburant -($this->tauxConsomation * 50);
          }
  /* cette fonction sert à donner un nombre de roues à un véhicule*/                 
  public function setRoue($R)
          {
            $this->roue=$R;
           }
  /* ces fonctions servent à l’affichage des attributs (propriétés) ou accesseurs */
  public function roue()
          {
              return $this->roue ;
          }
  public function carburant()
          {
              return $this->carburant ;
          }
    }
  ?>

Pour créer une classe fille Voiture de la classe Vehicule

1) la première manière :   il suffit d’ajouter le code suivant dans le fichier de la classe Vehicule :

Le code à ajouter :

Exemple :       Copier le code

   class Voiture extends Vehicule
       {    
            //  Déclaration des attributs   
            // Constructeur de la classe Voiture 
            public function __construct(int $prix_vehicule, bool $clim)    
            {
              //votre code ici
            }  
        // Méthode de la classe Vehicule
       }  

2) La seconde manière

Vous vous souvenu de l’auto chargement que nous avons vu dans un chapitre précédent dont voici la fonction que nous avons retenu pour déclarer une classe :

Exemple :       Copier le code

<?php
	function chargerClasse ($classe)
	{
		include( $classe.‘.php’ ); /* On inclue la classe correspondante au paramètre passé*/
	}
	
	spl_autoload_register ('chargerClasse'); /* enregistrement de la fonction en autoload pour qu'elle soit appelée dès qu'on instancie une classe non déclarée*/
  ?>

Et bien on peut aussi créer  notre classe fille dans un fichier indépendant à condition d’utiliser une fonction pour déclarer la classe mère ou tout simplement la fonction include.

Notre exemple de tout à l’heure devient comme suit :

Exemple :       Copier le code

<?php
	function chargerClasse ($classe)
	{
		include( $classe.’.php’ ); /* On inclue la classe correspondante au paramètre passé*/
	}
	
	spl_autoload_register ('chargerClasse'); /* enregistrement de la fonction en autoload pour qu'elle soit appelée dès qu'on instancie une classe non déclarée*/
      $classe= "Vehicule" ;
  class Voiture extends Vehicule
       {   
            //  Déclaration des attributs
            // Constructeur de la classe Voiture 
            public function __construct(int $prix_vehicule, bool $clim)
            {
              //votre code ici
            }  
        // Méthode de la classe Vehicule
} 
  ?>

Surcharger les méthodes

On vient de créer une classe fille qui hérite des propriétés de la classe parente.

Sachez que vous pouvez réécrire une méthode pour modifier son comportement, pour cela il suffit de redéclarer la méthode et d’écrire le code des instructions que vous voulez mettre dans cette méthode.

Exemple : 

Exemple :       Copier le code

  <?php
  class x {
   public $array = array();
   public function __construct($arg1, $arg2) {
    
    $this->array['arg1'] = $arg1;
    $this->array['arg2'] = $arg2;
   }
  }
  class y extends x {
   public function __construct($arg1, $arg2) {
   /* Je surcharge la méthode du constructeur, donc de ce fait je vais faire : ->
  Soit autre chose ; -> Soit je vais rajouter des fonctionnalités*/
    parent::__construct($arg1, $arg2); /* Ici j'appèle le constructeur
  de la classe parente. J'utilise donc les fonctionnalités de base.*/
  /* Dans ce qui suit  je modifie le comportement de la méthode constructeur*/
    $this->array['arg1-arg2'] = $this->array['arg1'] + $this->array['arg2']; 
  echo $this->array['arg1-arg2']; // Affichera 12 quand on instancie la classe y
   }
  }
  // on instancie la classe fille y
  $y1 = new y(14,8);
  ?>

Dans l’exemple nous avons un nouveau opérateur   parent::

Il arrive que vous ayez à écrire du code qui faire référence aux attributs et méthodes des classes parente.

Au lieu d'utiliser le nom littéral de votre classe parente dans votre code, vous pouvez utiliser le mot réservé parent  suivie du double deux points (parent::), qui représente votre classe parente (celle indiqué par extends , dans la déclaration de votre classe fille).

 Ainsi, vous éviter d'écrire le nom de votre classe parente directement dans votre code.

si la méthode parente retourne une valeur, vous pouvez la récupérer comme si vous appeliez une méthode normalement.

 Exemple

Exemple :       Copier le code

  <?php
      class A
      {
          public function MaMethode()
          {
              return 'MaMethode de la classe A';
          }
      }
      class B extends A
      {
          public function MaMethode()
          {
              $retour = parent::MaMethode();
             
              echo $retour; // Affiche 'MaMethode'
          }
      }
              $B1 = new B();
              echo $B1->MaMethode();
  ?>

Autre type de visibilité : protected


Nous allons maintenant voir le dernier type de visibilité existant en POO : il s'agit de protected.

Ce type de visibilité est  à placer entre public et private

Nous savons que :

  • public :  nous donne beaucoup de liberté. On peut accéder à l'attribut ou à la méthode de n'importe où. Toute classe fille aura accès aux éléments publics.
  • private :  nous donne le moins de liberté. On ne peut accéder à l'attribut ou à la méthode que depuis l'intérieur de la classe qui l'a créé. Toute classe fille n'aura pas accès aux éléments privés.

Le type de visibilité protected est en fait une petite modification du type private : il a exactement les mêmes effets que private, à l'exception que toute classe fille aura accès aux éléments protégés.

L'accès aux éléments protégés (protected) est limité aux classes et parents hérités (et à la classe qui a défini l'élément)

L'accès protégé ( protected ) est un intermédiaire entre l'accès publique et l'accès privé. Il permet d'utiliser des attributs et méthodes communs dans une classe parente et ses classes dérivées (héritantes).

Exemple :

Exemple :       Copier le code

  <?php
      class ClasseParente
      {
          protected $attributProtege;
          private $attributPrive;
         
          public function __construct()
          {
              $this->attributProtege = 'Je suis un attribut protégé!';
              $this->attributPrive = 'Je suis un attribut privé !';
          }
      }
      class ClasseFille extends ClasseParente
      {
          public function EcrireAttributs()
          {
              echo $this->attributProtege; /* L'attribut est protégé, on y accède
  donc à partir de la classse fille*/
              echo $this->atributPrive; /* L'attribut est privé, on n'y a pas
  accès,  rien ne s'affichera (ou une notice si les notices sont activées).*/
          }
      }
      $obj = new ClasseFille;
      /* si vous décommentez la ligne suivte vous aurez une Erreur fatale.*/
     // echo $obj->attributProtege;
      echo $obj->attributPrive; /* Rien ne s'affiche (ou une notice si les notices
  sont activées).*/
      $obj->EcrireAttributs(); /* Affiche « Je suis un attribut protégé! » suivi de
  rien  (ou une notice si les notices sont activées).*/
  ?>

Quant utiliser private ou protected ?

Et bien on utilise private si on empêcher totalement l’accès à l’élément à l’extérieur de la classe qui l’a créé.

Et on utilise  proected si on veut permettre aux classes filles l’accès à l’élément.

Abstraction de classes ou Classes abstraites


Jusqu’à présent nous avons vu qu’on peut instancier toute classe , mais on peut empêcher l’instanciation d’une classe. On parle alors de classe Abstraite. 

Pour déclarer une classe abstraite, il suffit de faire précéder le mot-clé class du mot-clé abstract comme ceci :

Exemple :       Copier le code

  <?php
      abstract class MaClasse // Notre classe est abstraite.
      {
      }
  ?>


Ainsi, si vous essayez de créer une instance de la classe Personnage, une erreur fatale sera levée.

Toutes les classes contenant au moins une méthode abstraite doivent également être abstraites.

Pour définir une méthode abstraite, il faut simplement déclarer la signature de la méthode et ne fournir aucune implémentation (c'est-à-dire on ne doit spécifier aucune instruction dans la méthode).

Exemple 1:

Exemple :       Copier le code

  <?php
      abstract class MaClasse
      {
          // On va forcer toute classe fille à réécrire cette méthode
          abstract public function MaFonction1();
         
          // Cette méthode n'aura pas besoin d'être réécrite.
          public function MaFonction2()
          {
              // Instructions.
          }
      }
  class MaClasseFille extends MaClasse
      {
          // On écrit la méthode « MaFonction1 » du même type de visibilité que la
  méthode abstraite « MaFonction1 » de la classe mère.
          public function MaFonction1()
          {
              // Instructions.
          }
      }  
  ?> 

Exemple 2:

Exemple :       Copier le code

  <?php
  abstract class AbstractClass
  {
      // Force la classe étendue à définir ces méthode
      abstract protected function getValue();
      abstract protected function prefixValue($prefix);
      // méthode commune
      public function printOut() {
          print $this->getValue() . "<br />";
     }
  }
  class ReelClass1 extends AbstractClass
  {
       protected function getValue() {
         return "Je suis ReelClass1";
       }
       public function prefixValue($prefix) {
         return "{$prefix}ReelClass1";
      }
  }
  class ReelClass2 extends AbstractClass
  {
       public function getValue() {
         return "Je suis ReelClass2";
       }
       public function prefixValue($prefix) {
         return "{$prefix}ReelClass2";
      }
  }
  $class1 = new ReelClass1;
  $class1->printOut();
  echo $class1->prefixValue('PRE_') ."<br />";
  $class2 = new ReelClass2;
  $class2->printOut();
  echo $class2->prefixValue('PRE_') ."<br />";
  ?>

Héritages multiples


Toute classe peut être héritée. Vous pouvez ainsi reproduire un réel arbre avec autant de classes héritant les unes des autres que vous le souhaitez.

 Exemple : 

Exemple :       Copier le code

  <?php
      class A
      {
        // Attributs
          //Méthodes
          {
         //Code de la méthode
          }
      }
      class B extends A
      {
          
        // Attributs
          //Méthodes
          {
         //Code de la méthode
          }
      }
   class C extends B
      {
         
        // Attributs
          //Méthodes
          {
         //Code de la méthode
          }
      }
  ?>

Et voilà ce long cours sur l’héritage . Mais je vous conseille de le relire plusieurs fois car c’est un concept très important dans la programmation orientée objet.

Par carabde 20 Aout 2014



Voir aussi nos tutoriel :

svg polygone

Dessin d’un polygone en SVG

Jouer des sons sur un Site Web

Navigateur et sons
Ce chapitre décrit comment insérer des multimédias audio (des sons) dans une page web.

Utiliser l'extension XSL de PHP 5 pour effectuer des Transformations XSL

Utiliser l'extension XSL de PHP 5 pour effectuer des Transformations XSL