Théorie générale sur la POO
La programmation orientée objet est un style de programmation qui associe à des éléments réels (un panier d'achat, par exemple), une série de variables et de fonctions.
Dans le domaine de la POO, la fonction d’un objet est appelée méthode et une variable attribut.
Pour que PHP puisse comprendre de quoi nous parlons, il est nécessaire de lui expliquer ce que représente l'objet, nous créons donc une classe d'objet.
Utilisation des classes
En PHP, la création d’une classe se fait en utilisant le mot-clé class suivit du nom de la classe puis d’un bloc d'instruction présentant les attributs et les méthodes de l'objet.
La déclaration d’une classe en PHP ressemble à ça :
class MaClasse {
var $un_attribut;
function une_methode() {
return true;
}
}
Les attributs sont assimilables à des variables local (un peu comme celles créées dans les fonctions, mais qui ne sont pas détruite tant que l’objet existe).
Il est possible d'attribuer des valeurs par défaut aux attributs en utilisant la syntaxe suivante :
class MaClasse {
var $un_attribut = 'La valeur par default';
/* À chaque création d’un objet de classe MaClasse, il sera automatiquement
doté d’un attribut $un_attribut contenant la chaine de caractères
'La valeur par default' */
function une_methode() {
return true;
}
}
Une fois la classe définie, on peut l’utiliser.
On va pour cela créer un objet de type MaClasse en utilisant le mot réservé new :
$mon_objet = new MaClasse;
La variable $mon_objet est désormais un objet de classe/type MaClasse (également appelé instance de MaClasse) et possède les attributs et méthodes définis plus haut. L'accès à ces informations s'effectue en utilisant ->.
Utilisation des attributs
Pour accéder à l'attribut $un_attribut, on écrit :
$mon_objet->un_attribut;
Attention! Pour accéder à un attribut, il ne faut pas utiliser le dollar $! Autrement, vous accédez à l'attribut portant le même nom que le contenu de la variable $un_attribut
$mon_objet = new MaClasse;
$mon_objet->un_attribut; // Accède à l'attribut "un_attribut"
$un_attribut = 'attribut2';
$mon_objet->$un_attribut; // Accède à l'attribut "attribut2", puisque la variable $un_attribut vaut attribut2.
L'espace de nom d’un objet est totalement séparé du reste du script. Deux variables, une dans l'espace de nom global (le script normal) peut porter le même nom que l'attribut d’un objet sans pour autant pointé vers le même contenu.
Il n’est pas obligatoire d'écrire les attributs dans la classe. Il est possible d'accéder à tout moment, à n’importe quel attribut de l'objet, pour autant que son nom soit un nom de variable valide.
Chaque objet possède ses propres attributs.
$objet1 = new MaClasse;
$objet2 = new MaClasse; // Deux objet de type MaClasse
$objet1->nom = 'Dupont'; // L'attribut nom de l’objet 1 vaut Dupont
$objet2->nom = 'Smith'; // L'attribut nom de l’objet 2 vaut Smith
echo $objet1->nom; // Affichera bien 'Dupont' et pas 'Smith'
Utilisation des méthodes
L'utilisation des méthodes est plus ou moins similaire à l’utilisation des attributs.
Par exemple, pour accéder à la méthode une_methode() définie plus haut, on va utiliser :
$mon_objet = new MaClasse;
$mon_objet->une_methode();
Les méthodes fonctionnent exactement comme les fonctions classiques de PHP.
De la même façon que les attributs, les méthodes possèdent un espace de nom séparé ; il est donc possible d'appeler une méthode str_replace(), même si cette fonction est définie par PHP.
Auto-Référence
Lors de la création de méthode d'objet, il peut être nécessaire d'accéder aux attributs de ce même objet, pour les modifier par exemple.
Vous pouvez alors utiliser l’objet magique $this représentant l’objet lui-même.
class MonClient {
var $nom = 'Dupont';
function smithize() {
$this->nom = 'Smith'; // Change l'attribut $nom de l'objet
}
}
$client = new MonClient;
echo $client->nom; // Affiche 'Dupont'
$client->smithize();
echo $client->nom; // Affiche 'Smith'
Constructeur
La programmation orientée objets basique en PHP permet l’utilisation des constructeurs. Il s'agit d’une méthode particulière destinée à initialiser l'objet.
Dans une classe, il ne peut y avoir qu'un seul constructeur.
En PHP4, afin qu'elle soit reconnue comme telle, elle doit porter le même nom que la classe (attention aux majuscules). En PHP5, le constructeur fait appel à une méthode au nom prédéfini, "__construct".
Syntaxe PHP 4
class MonClient {
var $nom;
function MonClient($nom) {
$this->nom = $nom;
}
}
Syntaxe PHP5
class MonClient {
public $nom;
function __construct($nom) {
$this->nom = $nom;
}
}
Dans ce cas, lors de la création de l’objet (l'instanciation), on précise le nom du client comme si l’on appelait la fonction.
$client = new MonClient('Dupont');
echo $client->nom; // Affiche Dupont
Pour rendre optionnelles les parenthèses, tous les paramètres de la méthode doivent être optionnels :
Syntaxe PHP4
class MonClient {
var $nom;
function MonClient($nom = '') {
$this->nom = $nom;
}
}
Syntaxe PHP5
class MonClient {
public $nom;
function __construct($nom = '') {
$this->nom = $nom;
}
}
$client = new MonClient('Dupont');
echo $client->nom; // Affiche Dupont
$client = new MonClient; // Ne produit pas d'erreur
echo $client->nom; // N'affiche rien, l'attribut $nom vaut une chaine de caractères vide
Destructeur
La destruction d’une instance se fait automatiquement à la fin d'exécution d’un script mais peut être décorée :)
Syntaxe PHP5
class MonClient {
public $nom;
function __destruct() {
$this->save();
echo 'Mon client est mort mais sauvegardé';
}
}
AutoLoad
Pour utiliser une classe il faut l'avoir
Syntaxe PHP5
Fichier autoload.php
function __autoload($class_name) {
require_once('./lib/'.$class_name.'.php');
}
Fichier index.php
require_once('./autoload.php');
new Client();//Lors de cette instanciation, autoload fera un require_once automatique :)
Surcharge
On appelle surcharge l'écrasement d’une méthode de la classe par une autre.
Ainsi dans l'exemple ci-dessus, la fonction "nom" est modifiée dans une deuxième classe :
class MonClient {
public $nom;
function __construct($nom) {
$this->nom = $nom;
}
}
$client = new MonClient('Dupont');
echo $client->nom."\n"; // Affiche Dupont
class LeClient {
public $nom;
function __construct($nom) {
$this->nom = strtoupper($nom);
}
}
$client = new LeClient('Dupont');
echo $client->nom; // Affiche DUPONT
Classes abstraites
Une classe abstraite est destinée à regrouper des éléments communs à ses classes filles. Elle ne doit donc jamais être déclarée comme "private" pour l'héritage (elle est "public" ou "protected"). Certaines de ses méthodes peuvent être abstraites aussi[1].
abstract class personne
{
public function nom($nom = "Dupont", $prenom = "Jean") {
$this->nom() = $nom;
$this->prénom() = $prenom;
}
}
class MonClient extends personne
{
$Client = new personne;
... // Ce qui distingue un client d’une autre personne
}
class Salarier extends personne
{
$Salarier = new personne;
... // Ce qui distingue un salarié d’une autre personne
}
Interface
Les interfaces rassemblent les méthodes publiques qui doivent être utilisées dans des classes. Donc s'il en manque une dans ces dernières, un message d'erreur apparait donc.
interface achat
{
public function afficher($article);
public function payer($article);
}
class ecommerce implements achat
{
public function afficher ($article) // Obligatoire
{
...
}
public function payer ($article) // Obligatoire
{
...
}
}