Cours PHP - leçon 13 - Bases de la POO (programmation orientée objet)

Lors des leçons précédentes, j'ai déjà parlé des types de données PHP suivants : booléens, entiers, nombres à virgule flottante, chaînes de caractères, tableaux. Dans cette leçon, je vais vous parler d’un autre type de données disponible en PHP — l’objet.
Les objets ressemblent un peu aux tableaux, car ils peuvent contenir différents types de données : nombres, texte, tableaux et même d’autres objets.

Les objets peuvent contenir d’autres types de données comme les tableaux. Ces données sont appelées propriétés (ou champs) de l’objet. De plus, les objets peuvent contenir des fonctions en eux-mêmes, que l’on appelle alors méthodes.

Mais les objets ont deux différences majeures avec les tableaux :

1. Les objets peuvent contenir des méthodes.

Les méthodes sont des fonctions appelées au nom de l’objet. Lier les fonctions à un objet permet de définir quelles opérations l’objet réalise et comment ces opérations s’appliquent aux objets.

2. Les objets sont créés à partir de classes.

Avant de créer un objet, on doit définir une classe. Dans la classe, on décrit quelles propriétés et méthodes l’objet aura. Cela définit la structure des objets et facilite la compréhension des données que l’objet doit contenir et des opérations qu’il doit réaliser. Lors de la création d’un objet à partir d’une classe, on peut initialiser cet objet avec des données afin que tous les objets nouvellement créés ne soient pas vides.

L’objet est probablement le conteneur le plus pratique pour stocker des données. Les objets en PHP permettent de modéliser des objets du monde réel, par exemple une base de données qui contient des informations sur des livres. Un livre a un auteur, un nombre de pages, un éditeur, un numéro d’édition, une critique, des données typographiques, etc. Pour faciliter le travail avec ces données, on regroupe tout dans une classe Livre, avec les propriétés Auteur, Nombre de pages, Éditeur, Numéro d’édition, Critique, Données typographiques, etc. Ainsi, on crée des objets qui ressemblent à de vrais livres. C’est particulièrement pratique puisque nos données seront stockées dans des tables avec des champs, on peut donc nommer les tables comme des classes, et les champs comme les propriétés des classes. Le travail avec les données sera ainsi grandement simplifié.

Nous verrons plus en détail les différences entre tableaux et objets à travers des exemples.

Fonctionnalités de PHP 5.2 et supérieures :

Commençons par définir la classe de nos objets. Notez que la classe est au singulier, les objets au pluriel — je souligne ainsi que d’une même classe on peut créer plusieurs objets :

<?php
class book{

}
?>

Le mot-clé class définit la classe pour nos futurs objets. Maintenant, créons des objets :

<?php
class book{
  
}

$book1 = new book;
$book2 = new book;
print_r($book1);
print_r($book2);
?>

Avec le mot-clé new on crée de nouveaux objets de la classe book. Chaque objet est appelé une instance de la classe. Ici, nous avons deux instances, $book1 et $book2. Avec print_r(), on affiche le contenu de ces objets :

PHP affiche la classe dont provient l’objet. S’il y avait des données, elles seraient aussi affichées. Passons maintenant à l’ajout de données. D’abord, définissons les propriétés de la classe. Depuis PHP 5.2, on définit les propriétés avec les mots-clés : public, protected, private (l’ancienne syntaxe var est aussi supportée, on en parlera plus tard). Si vous connaissez Delphi ou C++, ces mots-clés fonctionnent pareil.

public définit les propriétés et méthodes accessibles publiquement. On peut y accéder après création de l’objet. Nous allons utiliser public pour les propriétés des livres.

protected définit des propriétés et méthodes accessibles uniquement dans la classe elle-même et ses sous-classes. Un appel à un élément protégé depuis un objet provoquera une erreur. Nous verrons protected plus tard avec l’héritage.

private définit des propriétés et méthodes accessibles uniquement dans la classe elle-même, même pas dans les sous-classes.

Pour l’instant, utilisons public pour toutes les propriétés et méthodes.

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

Maintenant, ces propriétés sont accessibles dans les instances :

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
print '<pre>';
print_r($book1);
print_r($book2);
print '</pre>';

On obtient un objet rempli et un objet vide :

Vous voyez maintenant comment assigner des données à un objet. Passons aux méthodes. Les méthodes sont des fonctions appelées au nom de l’objet ou de la classe. Ajoutons des méthodes qui retournent chaque propriété :

<?php

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
  
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
print '<pre>';
print $book1->getAuthor() . '<br />';
print $book1->getNumberOfPages() . '<br />';
print $book1->getYear() . '<br />';
print $book1->getPublishingOffice() . '<br />';
print $book1->getEditionNumber() . '<br />';
print '</pre>';

?>

On accède aux propriétés via les méthodes, pas directement. Notez la variable $this qui fait référence à l’instance courante. Par exemple, dans l’objet $book1, $this correspond aux valeurs de $book1. $this permet d’utiliser les propriétés de l’objet dans ses méthodes. En dehors de la classe, $this n’est pas défini. Ajoutons deux méthodes pour afficher le livre sous forme de tableau et de div :

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
  public function displayTable(){
    $content = '<table style="border: 1px solid #000">';
    $content .= '<tr><td>Author</td><td>'. $this->getAuthor() . '</td></tr>';
    $content .= '<tr><td>Number of pages</td><td>'. $this->getNumberOfPages() . '</td></tr>';
    $content .= '<tr><td>Year</td><td>'. $this->getYear() . '</td></tr>';
    $content .= '<tr><td>Publishing office</td><td>'. $this->getPublishingOffice() . '</td></tr>';
    $content .= '<tr><td>Edition number</td><td>'. $this->getEditionNumber() . '</td></tr>';
    $content .= '</table>'; 
    return $content;
  }
  public function displayUnformatted(){
    $content = '<div style="border:1px solid #ddd">';
    $content .= '<label>Author:</label><div>'. $this->getAuthor() . '</div>';
    $content .= '<label>Number of pages:</label><div>'. $this->getNumberOfPages() . '</div>';
    $content .= '<label>Year:</label><div>'. $this->getYear() . '</div>';
    $content .= '<label>Publishing office:</label><div>'. $this->getPublishingOffice() . '</div>';
    $content .= '<label>Edition number:</label><div>'. $this->getEditionNumber() . '</div>';
    $content .= '</div>'; 
    return $content;
  }  
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
$book2->author = 'Leshkina S.O.';
$book2->numberOfPages = 200;
$book2->publishinOffice = 'Moscow';
$book2->editionNumber = 1;
print $book1->displayTable();
print $book2->displayUnformatted();

Ce code est assez lisible. J’ai oublié le nom du livre, ajoutons la propriété name et ses méthodes :

<?php

class book{
  public $author;
  public $name; // j’ai oublié ça.
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
  public function getAuthor(){
    return $this->author;
  }
  public function getName(){
    return $this->name;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
  public function displayTable(){
    $content = '<table style="border: 1px solid #000">';
    $content .= '<tr><td>Author</td><td>'. $this->getAuthor() . '</td></tr>';
    $content .= '<tr><td>Name</td><td>'. $this->getName() . '</td></tr>';
    $content .= '<tr><td>Number of pages</td><td>'. $this->getNumberOfPages() . '</td></tr>';
    $content .= '<tr><td>Year</td><td>'. $this->getYear() . '</td></tr>';
    $content .= '<tr><td>Publishing office</td><td>'. $this->getPublishingOffice() . '</td></tr>';
    $content .= '<tr><td>Edition number</td><td>'. $this->getEditionNumber() . '</td></tr>';
    $content .= '</table>'; 
    return $content;
  }
  public function displayUnformatted(){
    $content = '<div style="border:1px solid #ddd">';
    $content .= '<label>Author:</label><div>'. $this->getAuthor() . '</div>';
    $content .= '<label>Name:</label><div>'. $this->getName() . '</div>';
    $content .= '<label>Number of pages:</label><div>'. $this->getNumberOfPages() . '</div>';
    $content .= '<label>Year:</label><div>'. $this->getYear() . '</div>';
    $content .= '<label>Publishing office:</label><div>'. $this->getPublishingOffice() . '</div>';
    $content .= '<label>Edition number:</label><div>'. $this->getEditionNumber() . '</div>';
    $content .= '</div>'; 
    return $content;
  }  
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->name = 'Drupal: User guide';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
$book2->author = 'Leshkina S.O.';
$book2->name = 'Drupal: Fields, Images, Views';
$book2->numberOfPages = 200;
$book2->year = 2013;
$book2->publishinOffice = 'Moscow';
$book2->editionNumber = 1;
print $book1->displayTable();
print $book2->displayUnformatted();

?> 

Fonctionnalités de PHP 5.1.3 et antérieures :

Pour définir des propriétés (variables) dans une classe, on utilisait le mot-clé var.

<?php
class myClass{

}
?>

Voyons un exemple avec des tableaux et fonctions :

<?php
$newArray = array(1,2,3,4,5);

function _increment_all_elements($customArray){
  foreach($customArray as $key){
    $customArray[] = $key + 1;
  }
  return $customArray;
}

$newArray = _increment_all_elements($newArray);
print_r($newArray);
?>

Cet exemple n’a pas beaucoup de sens, on ajoute au tableau original ses éléments augmentés de 1. Mais le plus important est que c’est fait avec une fonction, base de la programmation fonctionnelle en PHP. Les objets ont une place particulière et cette programmation s’appelle orientée objet.
Nous reviendrons à cet exemple avec des objets, mais d’abord expliquons ce qu’est un objet.
Les objets, comme les fonctions, regroupent fonctions et données, mais d’une manière plus proche du monde réel. Par exemple, un objet produit peut avoir comme propriétés prix, poids, largeur, longueur. Cette proximité du monde réel facilite la compréhension du code.
Les objets sont généralement créés comme instances d’une classe, par exemple un objet « balle » peut être une instance de la classe « produit ». La classe est une abstraction décrivant propriétés et fonctions, l’objet est une réalisation concrète.
Créons notre première classe et objet :

<?php
class WorkWithArray{

}
?>

Le mot-clé class crée une classe, dans ses accolades on écrit propriétés et méthodes (fonctions). Les fonctions dans les classes sont appelées méthodes, les variables propriétés.
Ajoutons une propriété tableau :

<?php
class WorkWithArray{
  var $myArray = array();
}
?>

Notre classe a maintenant une propriété tableau, aussi appelée variable d’instance ou membre de données. On ajoute les propriétés avec le mot-clé var.
Ajoutons aussi une fonction :

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key + 1;
    }
    return $newArray;
  }
}
?>

Les fonctions s’ajoutent simplement. Créons un objet :

<?php
$myObject = new WorkWithArray;
print_r($myObject);
?>

On affiche l’objet avec print_r(). Maintenant, utilisons la propriété et la méthode :

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key + 1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
$myObject->myArray = array(2,4,6,7);
print_r($myObject);
?>

On accède aux propriétés via ->, c’est la flèche d’appartenance : « la propriété myArray appartient à l’objet myObject ».
Manipulons la propriété avec la méthode :

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key + 1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
$myObject->myArray = array(2,4,6,7);
$myObject->myArray = $myObject->increment_all_elements($myObject->myArray);
print_r($myObject);
?>

On appelle méthode et propriété via ->. Nous appelons increment_all_elements() avec la propriété myArray en paramètre et remplaçons cette propriété par le résultat. On affiche le tableau modifié.
C’est un exemple simple montrant la création d’objets et l’appel de leurs propriétés et méthodes. Nous approfondirons la programmation orientée objet plus tard.