PHP Orienté Objet

Suite a une demande qui m'a été faite, je vous présente un petit tutoriel pour vous initier au PHP Orienté Objet.

PHP Orienté Objet

Le PHP OO (qui a beaucoup changé dans la version 5) peut paraître simpliste mais est en générale suffisante pour son utilisation. Il faut garder en tête que PHP n'est PAS un langage Orienté Objet.

Base:
- il faut déclarer une classe (avec le mot clé class, suivit de son nom).
- cette déclaration se fait dans le fichier script (PHP n'a pas de header file), et doit être déclaré dans le code avant de créer des instances (comme en C).
- la déclaration de classe ne se termine pas par ";" comme en C++.
- il n'y a pas de déclaration de fonction (méthode) à faire. Il suffit de définir la fonction avec son code, à l'intérieur de la déclaration de la classe.
- pour créer une instance d'une classe, utiliser le mot clé new comme ceci : $mavar = new maclass();.
- le constructeur d'une classe s'appelle __construct() et est appelé automatiquement à l'instanciation d'une classe. Un constructeur peut accepter des arguments.
- le destructeur d'une classe s'appelle __destruct(), et est appelé automatiquement lors de la destruction explicite d'une instance.
- le constructeur par recopie se fait en définissant une méthode appelée __clone().

Exemple:

Code:

class maclass
{
   var $mvar;
   function mafonction() {
      $this->mvar = 100;
   }
}
$mavar = new maclass();

Accès:
- PHP OO supporte les droits d'accès private, public et protected, tout comme en C++. Si aucun accès n'est spécifié, public est par défaut. Ces accès doivent précéder les mots clés function ou var et être répéter à chaque ligne.
- pour accéder à la classe courante, utiliser la variable $this (comme le pointeur this en C++). N'est pas définie lors d'appels statiques.
- pour accéder a une donnée membre, utiliser l'opérateur flèche -> comme ceci : $mavar->longueur. Pour les méthodes utiliser $mavar->calculer();. Il est déconseillé d'accéder à une fonction statique par cet opérateur.
- pour appeler une méthode d'une classe non-instanciée (de manière statique), utiliser l'opérateur de résolution de portée comme ceci : maclass::calculer();. Dans ce contexte, $this n'est pas défini. Le mot clé static doit être spécifié après l'accès pour déclarer la méthode comme statique. Il est possible néanmoins d'appeler de manière statique une méthode qui n'a pas été déclarée ainsi.
- lors de la définition d'une méthode, il ne faut pas indiquer la valeur de retour. PHP est un langage de script très peu typé, et est capable pour une même fonction de retourner void, comme un objet, ou un tableau de string. Pour la même raison, les arguments en paramètres ne sont pas typés, mais il est néanmoins possible d'imposer un type aux arguments (seuls array ou les autres classes sont utilisables).

Exemple:

Code:

class maclass
{
   public $mvar;
   private $count = 0;
   public function mafonction() {
      $this->mvar = 100;
      $this->count++;
   }
   public function getcount() {
      return $this->count;
   }
   public static function fonctionstatic($val) {
      echo "(".$val.")";
   }
}
$mavar = new maclass();
$mavar->mafonction();
$count = $mavar->getcount();
maclass::fonctionstatic("cool");

Héritage, polymorphisme:
- les constructeurs (et destructeurs) de classes parentes ne sont pas appelés automatiquement. A vous de l'appeler explicitement avec parent::__construct() (et parent::__destruct()).
- pour qu'une classe hérite d'une autre classe, utiliser le mot clé extends comme ceci : class class1 extends class2 {}. Contrairement au C++, les héritages n'ont pas d'accès spécifiques.
- le mot clé self permet l'accès à la classe courante (et non pas à l'instance courante). Utile en cas d'héritage. Utilisation : self::calculer();.
- le mot clé parent permet l'accès à la classe parent directe (et non pas à l'instance courante). Utilisation: parent::calculer();.
- Une méthode ou une donnée membre peut être redéfinie par une classe fille. Il n'y a pas de mot clé virtual comme en C++, PHP va automatiquement rechercher la fonction accessible la plus dérivée.
- pour rendre une classe abstraite, rendant la classe instanciable que par héritage, faire précéder la classe du mot clé abstract. Pour rendre une méthode "virtuelle pure", rendant la classe in-instanciable tant que la méthode n'as pas été dérivée et définie, faire précéder la déclaration d'accès de la méthode par le mot clé abstract. De la même manière, une classe ou une méthode définie avec le mot clé final ne pourra plus être dérivé.

Exemple:

Code:

class maclass
{
   public $mvar;
   protected $count = 0;
   public function mafonction() {
      $this->mvar = 100;
      $this->count++;
   }
   public function getcount() {
      return $this->count;
   }
   public static function fonctionstatic($val) {
      echo "(".$val.")";
   }
   function __construct() {
      $this->mvar = 50;
   }
}
class maclass2 extends maclass
{
   function __construct() {
      parent::__construct();
      $this->mvar++;
   }
   public function mafonction() {
      $this->count--;
   }
}

$mavar = new maclass2();
$mavar->mafonction();
echo $mavar->getcount(); // affiche -1
echo $mavar->mvar; // affiche 51

Sémantique:
- chaque objet créé a une sémantique de valeur. On peut parcourir un objet comme si c'était un tableau avec foreach. Par exemple foreach($maclass AS $key => $val) { }, $key prendra le nom de toutes les données membres visibles, et $val leur valeurs respectives.
- comparer deux objets, utiliser l'opérateur == pour comparer les valeurs des données membres (deux objets identiques a et b, a == b retournera true). Utiliser l'opérateur === pour comparer les instances des deux classes (deux objets identiques a et b, a === b retournera false, car ce sont deux variables différentes. Si b était une référence de a, alors a === b retournerai true). Si a et b sont deux instances de deux classes différentes, mais qui ont les mêmes propriétés, alors a == b retournera false quand même.

Exemple:

Code:

class maclass
{
   public $val = 5;
   public $truc = 10;
}
class maclass2
{
   public $val = 5;
   public $truc = 10;
}

$mavar = new maclass();
foreach($mavar as $key => $val) {
   echo $key.' '.$val; // affichera : val 5 puis truc 10
}

$mavar_bis = new maclass();
$mavar2 = new maclass2();
if($mavar == $mavar_bis) echo "les deux objets ont les mêmes valeurs";
if($mavar !== $mavar_bis) echo "les deux objets ne sont pas les mêmes instances";
if($mavar !== $mavar2) echo "les deux objets sont de type différent";

Pour de plus amples informations, sur les méthodes magiques (getter, setter, caller, unsetter, insetter, sleep, wakeup, tostring, setstate, interfaces, intérateur, foncteurs, singletons, autoloader, l'API de réflexion, se reporter à la documentation officielle.

J'ai l'impression d'avoir loupé un cours là. Pour ma part je débute totalement sur le php. Alors j'apprécie le geste, vraiment. Mais au cas où, tu te tiens à disposition en cas de problèmes/questions ?

Biensûr. Pour un cour de PHP... bah on a eu 2 paquets de feuille donc je pense que y'a de quoi avoir des bases