Une classe est une collection de variables et de fonctions qui
fonctionnent avec ces variables. Une classe est définie
en utilisant la syntaxe suivante :
Exemple 18-1. Les classes en PHP
<?php
class Panier {
// Eléments de notre panier
var $items;
// Ajout de $num articles de type $artnr au panier
function add_item ($artnr, $num) {
$this->items[$artnr] += $num;
}
// Suppression de $num articles du type $artnr du panier
function remove_item($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
return true;
} elseif ($this->items[$artnr] == $num) {
unset($this->items[$artnr]);
return true;
} else {
return false;
}
}
}
?>
|
|
L'exemple ci-dessus définit la classe Panier qui est composée
d'un tableau associatif contenant les articles du panier et de deux
fonctions, une pour ajouter et une pour enlever des éléments
au panier.
| Avertissement |
Vous NE POUVEZ PAS couper la définition d'une
classe en plusieurs fichiers. De la même façon, vous NE POUVEZ
PAS couper la définition d'une classe en de multiples blocs, Ã
moins que la coupure ne soit à l'intérieure de la déclaration d'une
méthode. Ce qui suit ne fonctionnera pas :
Exemple 18-2. Ne pas couper la définition d'une classe
<?php
class test {
?>
<?php
function test() {
echo 'OK';
}
}
?>
|
|
Néanmoins, ce qui suit est autorisé :
Exemple 18-3. Changer de mode durant la définition d'une classe
<?php
class test {
function test() {
?>
<?php
print 'Ok';
}
}
?>
|
|
|
Les notes suivantes ne sont valables que pour PHP 4.
| Attention |
Le nom stdClass est utilisé en interne par
Zend et ne doit pas être utilisé. Vous ne pouvez pas nommer
une classe stdClass en PHP.
|
| Attention |
Les noms de fonctions __sleep et
__wakeup sont magiques en PHP. Vous ne pouvez
pas utiliser ces noms de fonctions dans vos classes, Ã moins
que vous ne souhaitiez utiliser la magie qui y est associée.
|
| Attention |
PHP se réserve l'usage de tous les noms de fonctions
commençant par __, pour sa propre magie.
Il est vivement recommandé de ne pas utiliser des noms de fonctions
commençant par __, Ã moins que vous ne
souhaitiez utiliser la magie qui y est associée.
|
Note :
En PHP 4, seuls les initialiseurs constants pour les variables
var sont autorisés. Utilisez les
constructeurs pour les initialisations variables, ou utilisant
des expressions.
Exemple 18-4. Initialisation de membres de classe
<?php
/* Aucune de ces syntaxes ne fonctionnera en PHP 4 */
class Panier {
var $date_du_jour = date("d/m/Y");
var $name = $firstname;
var $owner = 'Fred ' . 'Jones';
var $items = array("DVD", "Télé","Magnétoscope");
}
/* Voici comment cela doit se faire désormais. */
class Panier {
var $date_du_jour;
var $name;
var $owner;
var $items;
function Panier() {
$this->date_du_jour = date("d/m/Y");
$this->name = $GLOBALS['firstname'];
/* etc. */
}
}
?>
|
|
Les classes forment un type de variable. Pour créer une variable
du type désiré, vous devez utiliser l'opérateur new.
Exemple 18-5. Création d'un objet de classe
<?php
$cart = new Panier;
$cart->add_item("10", 1);
$another_cart = new Panier;
$another_cart->add_item("0815", 3);
?>
|
|
L'instruction ci-dessus crée l'objet $cart de la classe
Panier.
La fonction add_idem() est appelée afin d'ajouter
l'article numéro 10 dans le panier. 3 articles numéro 0815 sont
ajoutés au panier $another_cart.
$cart et $another_cart disposent des
fonctions add_item(), remove_item()
et de la variable items. Ce sont des fonctions
et variables distinctes. Vous pouvez vous représenter les
objets comme des dossiers sur votre disque dur. Vous pouvez
avoir deux fichiers lisez-moi.txt sur votre disque dur,
tant qu'ils ne sont pas dans le même répertoire. De même que vous
devez alors taper le chemin complet jusqu'au fichier, vous devez
spécifier le nom complet de la méthode avant de l'employer :
en termes PHP, le dossier racine est l'espace de nom global, et le
séparateur de dossier est ->. Par exemple,
les noms $cart->items et
$another_cart->items représentent deux
variables distinctes. Notez que le nom de la variable est alors
$cart->items, et non pas
$cart->$items : il n'y a qu'un seul
signe $ dans un nom de variable.
Exemple 18-6. Accès aux membres d'une classe
<?php
// correct, le signe $ est unique
$cart->items = array("10" => 1);
// incorrect, car $cart->$items devient $cart->""
$cart->$items = array("10" => 1);
// correct, mais risque de ne pas se comporter comme prévu
// $cart->$myvar devient $cart->items
$myvar = 'items';
$cart->$myvar = array("10" => 1);
?>
|
|
À l'intérieur d'une définition de classe, vous ne savez pas le
nom de la variable à partir duquel l'objet sera accessible dans
le script. On ne peut prévoir que l'objet créé sera
affecté Ã la variable $cart,
$another_cart ou quelque chose d'autres. Donc, vous ne
pouvez pas utiliser la syntaxe $cart->items. Mais pour
pouvoir accéder à aux méthodes et membres d'un objet, vous pouvez utiliser
la variable spéciale $this, qui peut s'interpréter comme
"moi-même", ou bien "l'objet courant". Par exemple,
'$this->items[$artnr] += $num;'
peut se lire comme 'ajouter $num au compteur
$artnr de mon propre tableau de compteur' ou bien
'ajouter $num au compteur $artnr du
tableau de compteurs de l'objet courant'.
Note :
La pseudo-variable $this n'est pas toujours définie si
la méthode dans laquelle elle est présente est appelée statiquement.
Cependant, ceci n'est pas une règle stricte : $this
est définie si une méthode est appelée statiquement depuis un autre objet.
Dans ce cas, sa valeur vaut l'objet appelé. Ce comportement est illustré
dans l'exemple ci-dessous :
Exemple 18-7. $this peut être indéfinie : cas d'une méthode statique
<?php
class A
{
function foo()
{
if (isset($this)) {
echo '$this est défini (';
echo get_class($this);
echo ")\n";
} else {
echo "\$this n'est pas défini.\n";
}
}
}
class B
{
function bar()
{
A::foo();
}
}
$a = new A();
$a->foo();
A::foo();
$b = new B();
$b->bar();
B::bar();
?>
|
L'exemple ci-dessus va afficher : $this est défini (a)
$this n'est pas défini.
$this est défini (b)
$this n'est pas défini. |
|
