Programmation orientée objet en PHP

Nous pouvons imaginer notre univers fait de différents objets comme le soleil, la terre, la lune etc. De même, nous pouvons imaginer notre voiture faite de différents objets comme le volant, la direction, l'équipement etc. implémenter un logiciel en utilisant différents objets.

Concepts orientés objet

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

• Class- 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.

• Object- 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.

• Member Variable- Ce sont les variables définies à l'intérieur d'une classe. Ces données seront invisibles à l'extérieur de la classe et seront accessibles via les fonctions membres. Ces variables sont appelées attribut de l'objet une fois qu'un objet est créé.

• Member function - Ce sont les fonctions définies dans une classe et sont utilisées pour accéder aux données des objets.

• Inheritance- Lorsqu'une classe est définie en héritant d'une fonction existante d'une classe parente, on l'appelle héritage. Ici, la classe enfant héritera de toutes ou de quelques fonctions membres et variables d'une classe parent.

• Parent class- Une classe héritée d'une autre classe. Ceci est également appelé une classe de base ou une super classe.

• Child Class- Une classe qui hérite d'une autre classe. Ceci est également appelé une sous-classe ou une classe dérivée.

• Polymorphism- 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 prendra un nombre d'arguments différent et pourra effectuer des tâches différentes.

• Overloading- 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.

• Data Abstraction - Toute représentation de données dans laquelle les détails d'implémentation sont masqués (abstraits).

• Encapsulation - fait référence à un concept où nous encapsulons toutes les données et fonctions membres ensemble pour former un objet.

• Constructor - 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 hors de portée.

Définition des classes PHP

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

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

Voici la description de chaque ligne -

• La forme spéciale class, suivi du nom de la classe que vous souhaitez définir.

• Un ensemble d'accolades englobant un nombre quelconque de déclarations de variables et de définitions de fonctions.

• Les déclarations de variables commencent par le formulaire spécial var, qui est suivi d'un nom de variable $ classique; 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'objets.

Exemple

Voici un exemple qui définit une classe de type Livres -

<?php
   class Books {
      /* Member variables */
      var $price;
      var $title;
      
      /* Member functions */
      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 $thisest une variable spéciale et se réfère au même objet ie. lui-même.

Créer des 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 denew opérateur.

$physics = new Books;
$maths = new Books;
$chemistry = new Books;

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 aux fonctions membres et traiter les variables membres.

Appel de fonctions membres

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

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

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

$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 du constructeur

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

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

L'exemple suivant créera un constructeur pour la classe Livres et 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 pas besoin d'appeler la fonction set séparément pour définir le prix et le titre. Nous ne pouvons initialiser ces deux variables membres qu'au moment de la création de l'objet. 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 );

/* Get those set values */
$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 Child 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 -

• Dispose automatiquement de 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 Books et ajoute plus de fonctionnalités en fonction de l'exigence.

class Novel extends Books {
   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 enfants remplacent les définitions portant le même nom dans les classes parentes. Dans une classe enfant, on peut 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;
}

Membres publics

Sauf indication contraire de votre part, 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é

• Depuis 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 du public. Si vous souhaitez limiter l'accessibilité des membres d'une classe, vous définissez les membres de la classe commeprivate ou protected.

Membres privés

En désignant un membre privé, vous limitez son accessibilité à la classe dans laquelle il est déclaré. Le membre privé ne peut pas être référencé à partir des 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 private mot-clé en face du membre.

class MyClass {
   private $car = "skoda";
   $driver = "SRK";
   
   function __construct($par) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
   
   function myPublicFunction() {
      return("I'm visible!");
   }
   
   private function myPrivateFunction() {
      return("I'm  not visible outside!");
   }
}

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

Membres protégés

Une propriété ou une méthode protégée 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 protégé en utilisantprotected mot-clé devant le membre.

Voici une version différente de MyClass -

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

   function __construct($par) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
   
   function myPublicFunction() {
      return("I'm visible!");
   }
   
   protected function myPrivateFunction() {
      return("I'm  visible in child class!");
   }
}

Interfaces

Les interfaces sont définies pour fournir un nom de fonction commun aux implémenteurs. Différents développeurs 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() Definition goes here
}

Constantes

Une constante est un peu comme 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) {
      // Statements here run every time
      // an instance of the class
      // is created.
   }
}

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 $ de début, contrairement aux noms de variables.

Classes 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, comme ça -

Lors de l'héritage d'une classe abstraite, toutes les méthodes marquées abstract 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 fonction à 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 fonction abstraites dans une classe non abstraite.

Mot-clé statique

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 ne peut pas être accédé 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 en cours de définition définitive, elle ne peut pas être étendue.

L'exemple suivant entraîne une erreur fatale: impossible de remplacer la méthode finale 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>";
      }
   }
?>

Appeler 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 des fonctions NameSub1 en appelant son constructeur parent explicitement à l'aide de la syntaxe :: (en passant deux de ses arguments), puis en définissant un champ supplémentaire. De même, NameSub1 définit sa fonction toString () non constructeur en termes de fonction parent qu'elle remplace.

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