Différences

Ci-dessous, les différences entre deux révisions de la page.

--- informatique:programmation:php:poo [2011/10/19 03:36] – benoit
+++ informatique:programmation:php:poo [2011/10/19 18:22] (Version actuelle) – benoit
@@ Ligne 319: / Ligne 319: @@
   * L'opérateur **->** : cet opérateur permet d'accéder à un élément de tel objet
   * L'opérateur **::** : cet opérateur permet d'accéder à un élément de telle classe
+===== Héritage =====
+==== Déclaration de classes filles et portée des éléments ====
+<sxh php>
+  <?php
+  class ClasseMere
+  {
+    // Un attribut protected est un attributs pouvant être transmise
+    // L'utilisation de protected au lieu de private et conseillé pour faciliter l'accès aux classes filles
+    protected $attributProtege = 'protégé';
+    private $attributPrive = 'privé';
+    public $attributPublic = 'publique';
+  }
+  // Ceci est une classe qui hérite des attributs et méthode de ClasseMere
+  // Elle hérite des éléments public ou protected mais pas private
+  class ClasseFille extends ClasseMere
+  {
+    public function get()
+    {
+      // Ci dessous aucun problème d'accès à l'attribut
+      echo $this->attributPublic."\n";
+      // Ci dessous aucun problème d'accès tant que l'on est dans une classe fille
+      echo $this->attributProtege."\n";
+      // La directive ci-dessous génèrera une erreur car la classe fille ne peut pas hériter d'attributs privés
+      echo $this->attributPrive."\n";
+    }
+  }
+  // On peut créer autant de classes fille que l'on veut
+  class ClasseGarcon extends ClasseMere
+  {
+  }
+  // On peut créer une arborescence de classe (tous les éléments parents public ou protected seront hérétées)
+  class ClassePetiteFille extends ClasseFille
+  {
+  }
+  $truc1 = new ClasseMere;
+  $truc2 = new ClasseFille;
+  // Ici on lance notre méthode get qui affichera une erreur à cause de l'attribut privé qui ne peut pas être affiché ici
+  $truc2->get();
+  //Ci-dessous il n'y a aucun problème pour accéder à un attribut public en dehors d'une classe
+  echo $truc2->attributPublic."\n";
+  //La directive ci-dessous génèrera une erreur car la classe fille ne peut pas hériter d'attributs privés
+  echo $truc2->attributProtege."\n";
+  ?>
+</sxh>
+==== Réécrire une méthode héritée ====
+<sxh php>
+  <?php
+  class A
+  {
+    public function test()
+    {
+      return "test";
+    }
+  }
+  class B extends A
+  {
+    public function test()
+    {
+      // Ici on dit que $retour est égale au resultat de la methode "test" de la classe parente
+      $retour = parent::test();
+      return $retour." avec des chose en plus\n";
+    }
+  }
+  $trucA = new A;
+  $trucB = new B;
+  echo $trucA->test();
+  echo "\n";
+  echo $trucB->test();
+  ?>
+</sxh>
+Resultat attendu :
+  test
+  test avec des chose en plus
+==== Imposer des contraintes ====
+Restreindre l'utilisation d'une classe qu'aux classes filles.
+<sxh php>
+  <?php
+  abstract class ClasseMere
+  {
+  }
+  class ClasseFille extends ClasseMere
+  {
+  }
+  $truc1 = new ClasseFille; //Aucun problème pour utiliser la classe ClasseFille
+  $truc2 = new ClasseMere; //En revanche il y a une restriction pour utiliser la classe ClasseMere. Une erreur aura lieu.
+  ?>
+</sxh>
+Obliger les classes filles à réécrire certaines méthodes de la classe parente.
+<sxh php>
+  <?php
+  abstract class ClasseMere
+  {
+    //Pour définir une méthode comme étant abstraite, il faut que la classe elle-même soit abstraite !
+    abstract public function Afficher();
+    // Il n'y a pas d'instruction dans cette methode, Elle ne peut pas en contenir
+    // Les classes Filles seront toutes obligées de réécrire le methode Afficher()
+  }
+  class ClasseFille extends ClasseMere
+  {
+    public function Afficher()
+    {
+      echo "Methode obligatoirement ecrite dans la classe fille\n";
+    }
+  }
+  $truc = new ClasseFille;
+  $truc->Afficher();
+  ?>
+</sxh>
+Restreindre l'héritage d'une classe (classe finale ne pouvant être héritée) et la empêcher réécriture d'une methode.
+<sxh php>
+  <?php
+  abstract class ClasseMere
+  {
+    // Ceci est une methode finale ne pouvent être héritée
+    final public function Methode()
+    {
+      echo "Hello\n";
+    }
+  }
+  // Cette classe est déclarée comme finale, aucun classe ne peut en hériter
+  final class ClasseFille extends ClasseMere
+  {
+    // Erreur fatale, car le methode "Methode" était déclarée comme final dans la classe parente.
+    public function Methode()
+    {
+    }
+  }
+  // Erreur fatale, car notre classe hérite d'une classe finale.
+  class ClassePetiteFille extends ClasseFille
+  {
+  }
+  ?>
+</sxh>
+==== Résolution statique à la volée ====
+<sxh php>
+  <?php
+  class Mere
+  {
+    public static function lancerLeTest()
+    {
+       self::quiEstCe();
+    }
+    public function quiEstCe()
+    {
+      echo "Je suis la classe Mere !\n";
+    }
+  }
+  class Enfant extends Mere
+  {
+    public function quiEstCe()
+    {
+       echo 'Je suis la classe Enfant !';
+    }
+  }
+  Enfant::lancerLeTest();
+  ?>
+</sxh>
+Résultat attendu :
+  Je suis la classe Mere !
+==== Pour résumer ====
+  * Avec l'attribut **protected** il est possible de permettre au classe fille d'utiliser l'attribut contrairement à l'attribut **private**
+  * **abstract** dans une classe empèche d'utiliser cette classe en dehors d'une classe fille
+  * **abstract** dans une méthode oblige les classes filles à réécrire la méthode.
+  * **final** permet de déclarer une méthode ou classe comme non "héritable"
+  * **parent::methode()** permet de reprendre les éléments d'une methode parente y ajouter modifier des éléments