Outils pour utilisateurs

Outils du site


informatique:programmation:php:poo

Différences

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

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision
Révision précédente
informatique:programmation:php:poo [2011/10/18 21:51]
benoit
informatique:programmation:php:poo [2018/09/06 19:10] (Version actuelle)
Ligne 2: Ligne 2:
  
   #   #
-  ​ 
-  ​ 
-  ​ 
-  ​ 
   ​   ​
   ​   ​
Ligne 151: Ligne 147:
   hello   hello
   22   22
 +
 +=== Pour résumer ===
 +  * Le constructeur est la fonction qui permet de définir les caractéristiques de notre objet.
 +  * Il ne peut y avoir qu'un seul constructeur dans une classe
  
 ===== Interaction entre les objets ===== ===== Interaction entre les objets =====
Ligne 317: Ligne 317:
  
 === Pour résumer === === Pour résumer ===
-  * 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 tel objet 
-  * L'​opérateur :: : cet opérateur permet d'​accéder à un élément de telle classe+  * 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
informatique/programmation/php/poo.1318967485.txt.gz · Dernière modification: 2018/09/06 19:00 (modification externe)