Programmation orientée objet en PHP

Concepts orientés objet

Avant d'entrer dans les détails, définissons les termes importants liés à la programmation orientée objet.

• Classe - Il s'agit d'un type de données défini par le programmeur, qui comprend des fonctions locales ainsi que des données locales. Vous pouvez considérer une classe comme un modèle pour créer de nombreuses instances du même type (ou classe) d'objet.
• Objet - Une instance individuelle de la structure de données définie par une classe. Vous définissez une classe une fois, puis créez de nombreux objets qui lui appartiennent. Les objets sont également appelés instance.
• Variable membre - Ce sont les variables définies à l'intérieur d'une classe. Ces données seront invisibles à l'extérieur de la classe et accessibles via les fonctions membres. Ces variables sont appelées attribut de l'objet une fois qu'un objet est créé.
• Fonction membre - Il s'agit de la fonction définie à l'intérieur d'une classe et utilisée pour accéder aux données de l'objet.
• Héritage - Lorsqu'une classe est définie en héritant d'une fonction existante d'une classe parente, elle est appelée héritage. Ici, la classe enfant héritera de toutes ou de quelques fonctions et variables membres d'une classe parent.
• Classe parent - Une classe héritée d'une autre classe. Ceci est également appelé une classe de base ou une super classe.
• Classe enfant - Une classe qui hérite d'une autre classe. Ceci est également appelé une sous-classe ou une classe dérivée.
• Polymorphisme - Il s'agit d'un concept orienté objet où la même fonction peut être utilisée à des fins différentes. Par exemple, le nom de la fonction restera le même, mais il prend un nombre différent d'arguments et peut effectuer une tâche différente.
• Surcharge - un type de polymorphisme dans lequel certains ou tous les opérateurs ont des implémentations différentes selon les types de leurs arguments. De même, les fonctions peuvent également être surchargées avec une implémentation différente.
• Abstraction de données - Toute représentation de données dans laquelle les détails de mise en œuvre sont masqués (abstraits)
• Encapsulation - fait référence à un concept dans lequel nous encapsulons toutes les données et les fonctions membres ensemble pour former un objet.
• Constructeur - fait référence à un type spécial de fonction qui sera appelée automatiquement chaque fois qu'il y a une formation d'objet à partir d'une classe.
• Destructor - fait référence à un type spécial de fonction qui sera appelée automatiquement chaque fois qu'un objet est supprimé ou sort de la portée.

Decouvrir plus de détails sur la programmation orienté objet dans cet article.

Définition des classes PHP

La forme générale pour définir une nouvelle classe en PHP est la suivante  :

<?php
   class MyClass {
      var $var1;
      var $var2 = "constant string";
      
      function myfunc ($arg1, $arg2) {
         [..]
      }
      [..]
   }
?>

Voici la description de chaque ligne −

• Le mot-clé class, suivie du nom de la classe que vous souhaitez définir.
• Un ensemble d'accolades entourant un nombre quelconque de déclarations de variables et de définitions de fonctions.
• Les déclarations de variable commencent par la forme spéciale var , qui est suivie d'un nom de variable $ conventionnel ; ils peuvent également avoir une affectation initiale à une valeur constante.

Les définitions de fonction ressemblent beaucoup à des fonctions PHP autonomes mais sont locales à la classe et seront utilisées pour définir et accéder aux données d'objet.

Voici un exemple qui définit une classe de type Book :

 

<?php
   class Book {
      /* Propriétés */
      var $price;
      var $title;
      
      /* Méthodes */
      function setPrice($par){
         $this->price = $par;
      }
      
      function getPrice(){
         echo $this->price ."<br/>";
      }
      
      function setTitle($par){
         $this->title = $par;
      }
      
      function getTitle(){
         echo $this->title ." <br/>";
      }
   }
?>

La variable $this est une variable spéciale et elle fait référence au même objet, c'est-à-dire. lui-même.

Création d'objets en PHP

Une fois que vous avez défini votre classe, vous pouvez créer autant d'objets que vous le souhaitez de ce type de classe. Voici un exemple de création d'objet à l'aide d'un nouvel opérateur.

$physics = new Book;
$maths = new Book;
$chemistry = new Book;

Ici, nous avons créé trois objets et ces objets sont indépendants les uns des autres et ils auront leur existence séparément. Ensuite, nous verrons comment accéder à la fonction membre (méthode) et traiter les variables membres (propriétés).

Fonctions de membre appelant

Après avoir créé vos objets, vous pourrez appeler des fonctions membres liées à cet objet. Une fonction membre ne pourra traiter que la variable membre de l'objet connexe.

L'exemple suivant montre comment définir le titre et les prix des trois livres en appelant les fonctions membres.

 

$physics->setTitle( "Physics for High School" );
$chemistry->setTitle( "Advanced Chemistry" );
$maths->setTitle( "Algebre" );


$physics->setPrice( 10 );
$chemistry->setPrice( 15 );
$maths->setPrice( 7 );

Maintenant, vous appelez une autre fonction membre pour obtenir les valeurs définies par l'exemple ci-dessus :

$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Cela produira le résultat suivant : 

 

Physics for High School
Advanced Chemistry
Algebra
10
15
7

Fonctions constructeur

Les fonctions de constructeur sont des types spéciaux de fonctions qui sont appelées automatiquement chaque fois qu'un objet est créé. Nous profitons donc pleinement de ce comportement, en initialisant de nombreuses choses via des fonctions constructeurs.

PHP fournit une fonction spéciale appelée __construct() pour définir un constructeur. Vous pouvez passer autant d'arguments que vous le souhaitez dans la fonction constructeur.

L'exemple suivant créera un constructeur pour la classe Book et il initialisera le prix et le titre du livre au moment de la création de l'objet.

 

function __construct( $par1, $par2 ) {
$this->title = $par1;
$this->price = $par2;
}

Maintenant, nous n'avons plus besoin d'appeler la fonction set séparément pour définir le prix et le titre. Nous pouvons initialiser ces deux variables membres au moment de la création de l'objet uniquement. Vérifiez l'exemple suivant ci-dessous : 

 

$physics = new Books( "Physics for High School", 10 );

$maths = new Books ( "Advanced Chemistry", 15 );

$chemistry = new Books ("Algebra", 7 );

 

/* Récuperer les valeurs */
$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();

$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Cela produira le résultat suivant : 

Physics for High School

Advanced Chemistry

Algebra

10

15

7

Destructeur

Comme une fonction constructeur, vous pouvez définir une fonction destructrice en utilisant la fonction __destruct() . Vous pouvez libérer toutes les ressources avec un destructeur.

Héritage

Les définitions de classe PHP peuvent éventuellement hériter d'une définition de classe parent en utilisant la clause extend. La syntaxe est la suivante : 

class Enfant extends Parent {
    <definition body>
}

L'effet de l'héritage est que la classe enfant (ou sous-classe ou classe dérivée) a les caractéristiques suivantes : 

• A automatiquement toutes les déclarations de variable membre de la classe parent.
• A automatiquement toutes les mêmes fonctions membres que le parent, qui (par défaut) fonctionneront de la même manière que ces fonctions dans le parent.

L'exemple suivant hérite de la classe Book et ajoute plus de fonctionnalités en fonction des besoins.

class Novel extends Book {
   var $publisher;
   function setPublisher($par){
      $this->publisher = $par;
   }

   function getPublisher(){
      echo $this->publisher. "<br />";
   }
}

Désormais, en dehors des fonctions héritées, la classe Novel conserve deux fonctions membres supplémentaires.

Remplacement de fonction

Les définitions de fonction dans les classes enfant remplacent les définitions portant le même nom dans les classes parent. Dans une classe enfant, nous pouvons modifier la définition d'une fonction héritée de la classe parent.

Dans l'exemple suivant, les fonctions getPrice et getTitle sont remplacées pour renvoyer certaines valeurs.

 

function getPrice() {
   echo $this->price . "<br/>";
   return $this->price;
}
   
function getTitle(){
   echo $this->title . "<br/>";
   return $this->title;
}

Propriétés publics

Sauf indication contraire, les propriétés et les méthodes d'une classe sont publiques. C'est-à-dire qu'ils peuvent être consultés dans trois situations possibles : 

• De l'extérieur de la classe dans laquelle il est déclaré
• De l'intérieur de la classe dans laquelle il est déclaré
• Depuis une autre classe qui implémente la classe dans laquelle elle est déclarée

Jusqu'à présent, nous avons vu tous les membres comme des membres publics. Si vous souhaitez limiter l'accessibilité des membres d'une classe, vous définissez les membres de la classe comme privés (private) ou protégés (protected).

Propriétés privés

En désignant une propriété private, vous limitez son accessibilité à la classe dans laquelle il est déclaré. Le membre privé ne peut pas être référencé à partir de classes qui héritent de la classe dans laquelle il est déclaré et n'est pas accessible depuis l'extérieur de la classe.

Un membre de classe peut être rendu privé en utilisant le mot-clé private devant le membre.

class MyClass {
   private $car = "skoda";
   $driver = "SRK";
   
   function __construct($par) {
   }
   
   function myPublicFunction() {
      return("Je suis visible !");
   }
   
   private function myPrivateFunction() {
      return("Je ne suis pas visible en dehors!");
   }
}

Lorsque la classe MyClass est héritée par une autre classe utilisant des extensions, Function() myPublic sera visible, tout comme $driver. La classe d'extension n'aura aucune connaissance ni accès à myPrivateFunction et $car, car ils sont déclarés privés.

Propriétes protégés

Une propriété ou une méthode protected est accessible dans la classe dans laquelle elle est déclarée, ainsi que dans les classes qui étendent cette classe. Les membres protégés ne sont pas disponibles en dehors de ces deux types de classes. Un membre de classe peut être rendu protégé en utilisant le mot-clé protected devant le membre.

Voici une version différente de MyClass :

class MyClass {
   protected $car = "skoda";
   $driver = "SRK";

   function __construct($par) {
   }
   
   function myPublicFunction() {
      return("je suis visible!");
   }
   
   protected function myPrivateFunction() {
      return("Je suis visible dans la classe enfant!");
   }
}

Interfaces

Les interfaces sont définies pour fournir des noms de fonction communs aux implémenteurs. Différents implémenteurs peuvent implémenter ces interfaces en fonction de leurs besoins. Vous pouvez dire que les interfaces sont des squelettes qui sont implémentés par les développeurs.

Depuis PHP5, il est possible de définir une interface, comme celle-ci :

interface Mail {
   public function sendMail();
}

Ensuite, si une autre classe implémentait cette interface, comme ceci :

class Report implements Mail {
   /* sendMail() sera definit ici */
}

Constantes

Une constante ressemble un peu à une variable, en ce sens qu'elle contient une valeur, mais ressemble plus à une fonction car une constante est immuable. Une fois que vous déclarez une constante, elle ne change pas.

Déclarer une constante est facile, comme cela se fait dans cette version de MyClass -

 

class MyClass {
   const requiredMargin = 1.7;
   
   function __construct($incomingValue) {
   }
}

Dans cette classe, requiredMargin est une constante. Il est déclaré avec le mot-clé const et ne peut en aucun cas être changé en autre chose que 1.7. Notez que le nom de la constante n'a pas de signe $, contrairement aux noms de variables.

Classe abstraites

Une classe abstraite est une classe qui ne peut pas être instanciée, seulement héritée. Vous déclarez une classe abstraite avec le mot clé abstract,

Lors de l'héritage d'une classe abstraite, toutes les méthodes marquées abstraites dans la déclaration de classe du parent doivent être définies par l'enfant ; de plus, ces méthodes doivent être définies avec la même visibilité.

abstract class MyAbstractClass {
   abstract function myAbstractFunction() {
   }
}

Notez que les définitions de fonctions à l'intérieur d'une classe abstraite doivent également être précédées du mot clé abstract. Il n'est pas légal d'avoir des définitions de fonctions abstraites à l'intérieur d'une classe non abstraite.

Mot-clé static

Déclarer des membres de classe ou des méthodes comme statiques les rend accessibles sans avoir besoin d'une instanciation de la classe. Un membre déclaré comme statique n'est pas accessible avec un objet de classe instancié (bien qu'une méthode statique le puisse).

Essayez l'exemple suivant  :

 

<?php
   class Foo {
      public static $my_static = 'foo';
      
      public function staticValue() {
         return self::$my_static;
      }
   }
 
   print Foo::$my_static . "\n";
   $foo = new Foo();
   
   print $foo->staticValue() . "\n";
?> 

Mot-clé final

PHP 5 introduit le mot-clé final, qui empêche les classes enfants de remplacer une méthode en préfixant la définition avec final. Si la classe elle-même est définie comme final, elle ne peut pas être étendue.

L'exemple suivant entraîne une erreur fatale : impossible de remplacer la méthode final BaseClass::moreTesting()

<?php
   class BaseClass {
      public function test() {
         echo "BaseClass::test() called<br>";
      }
      
      final public function moreTesting() {
         echo "BaseClass::moreTesting() called<br>";
      }
   }
   
   class ChildClass extends BaseClass {
      public function moreTesting() {
         echo "ChildClass::moreTesting() called<br>";
      }
   }
?>

Appel des constructeurs parents

Au lieu d'écrire un constructeur entièrement nouveau pour la sous-classe, écrivons-le en appelant explicitement le constructeur du parent, puis en faisant tout ce qui est nécessaire en plus pour l'instanciation de la sous-classe. Voici un exemple simple : 

class Name {
   var $_firstName;
   var $_lastName;
   
   function Name($first_name, $last_name) {
      $this->_firstName = $first_name;
      $this->_lastName = $last_name;
   }
   
   function toString() {
      return($this->_lastName .", " .$this->_firstName);
   }
}
class NameSub1 extends Name {
   var $_middleInitial;
   
   function NameSub1($first_name, $middle_initial, $last_name) {
      Name::Name($first_name, $last_name);
      $this->_middleInitial = $middle_initial;
   }
   
   function toString() {
      return(Name::toString() . " " . $this->_middleInitial);
   }
}

Dans cet exemple, nous avons une classe parente (Name), qui a un constructeur à deux arguments, et une sous-classe (NameSub1), qui a un constructeur à trois arguments. Le constructeur de NameSub1 fonctionne en appelant explicitement son constructeur parent à l'aide de la syntaxe :: (en transmettant deux de ses arguments), puis en définissant un champ supplémentaire. De même, NameSub1 définit sa fonction non constructeur toString() en fonction de la fonction parent qu'il remplace.

NOTE : Un constructeur peut être défini avec le même nom que le nom d'une classe. comme défini dans l'exemple ci-dessus.