 Accueil
Trucs & Astuces
Scripts
Regex
Annuaire
 Articles
.
|
 Articles  Les Classes en PHP Par MiK
Octobre 2000 
» Introduction
» Structure d'une classe
» Méthodes et Propriétés
» L'instruction $this
» Objets et Instances
» Constructeurs et Héritages
» Conclusion
» Liens
L'utilisation de classes permet d'écrire ses programmes PHP avec plus de flexibilité. Elles permettent de ne pas avoir à réécrire les mêmes codes dix fois de suite : une fois un composant créé, il peut être utilisé autant de fois que nécessaire, en en créant une nouvelle 'instance'.
Chaque instance est en fait un objet, qui dispose de ses propres méthodes et propriétés (nous le verrons plus loin).
Il est conseillé de garder ses classes dans un fichier à part, nommé cls.inc par exemple ou bien utile.inc et de l'inclure en fonction des besoins.
Assez discuté, passons à la pratique !
Chaque instance d'une classe (objets) aura la même structure (mêmes fonctions, mêmes propriétés), mais la valeur de chaque propriété pourra changer selon l'objet.
Si nous avons les objets "obj1" et "obj2" créés depuis la classe 'avion', et que cette classe comporte une propriété nommée 'destination', la valeur de cette propriété pourra être égale à "New York" pour obj1 et à "Paris" pour obj2.
De la même manière que pour définir une fonction, la structure d'une classe est située entre les deux accolades et le nom de la classe est indiqué après le mot clé 'class'.
class employe {
# Structure de la classe
# ...
}
|
|
Les propriétés de la classe sont en fait des variables (qui seront propres à chaque instance de la classe) et que l'on déclare au début de la classe, avant les méthodes, grâce au mot clé 'var'.
class employe {
// Déclaration d'une propriété, 'nom'
var $nom;
// Déclaration d'une propriété 'poste'
// et affectation d'une valeur par défaut
var $poste = 'Journaliste';
// …
}
|
|
Les méthodes d'une classe ne sont en fait que des fonctions ordinaires incluses entre les deux accolades délimitant la classe, après la déclaration des propriétés.
class employe {
var $nom;
var $poste = 'Journaliste';
function renvoyer() {
// Contenu de la fonction
// …
}
function payer($combien = '10000') {
// Contenu de la fonction
// …
}
}
|
|
Dans la méthode d'une classe, vous pouvez avoir besoin de faire référence à une autre méthode ou à une propriété.
Cet accès est possible grâce à la variable $This.
$This représente en fait l'objet lui-même.
Exemple :
class employe {
var $nom;
var $poste = "Journaliste";
var $lieu = "Paris";
Function muter($vers) {
$this->lieu = $vers;
}
}
$Harry = new employe;
$Jean = new employe;
$Harry->muter("Lyon");
|
|
La propriété lieu de l'objet Jean est inchangée ("Paris"), mais la propriété lieu de l'objet Harry est maintenant égale à "Lyon".
La structure d'une classe de base est maintenant définie, mais encore faut-il l'utiliser.
Le mot clé 'new' permet de créer une nouvelle instance d'une classe (un nouvel objet en fait).
$employe[0] = new employe;
$monobjet = new employe;
|
|
On utilise ensuite un accesseur pour accéder aux fonctions et propriétés d'un objet.
Il s'agit du signe '->', en PHP.
$monobjet->poste = "Balayeur";
$monobjet->payer("50");
$obj2->poste = "PDG";
|
|
La propriété poste de obj2 et celle de monobjet sont différentes.
Il s'agit de deux objets distincts, même s'ils sont issus de la même classe.
Un constructeur est une fonction permettant d'effectuer certains traitements lors de la création d'un objet.
Dans la pratique, il s'agit juste d'une fonction normale, incluse dans la classe comme une méthode, mais qui porte le même nom que la classe.
Si la fonction constructrice requiert un ou plusieurs paramètres, ceux-ci doivent être indiqués lors de la création via le mot clé new.
Exemple :
class employe {
var $poste;
var $lieu;
var $salaire;
function employe($poste, $lieu='Paris', $salaire='15000') {
$this->poste = $poste;
$this->lieu = $lieu;
$this->salaire = $salaire;
echo "Un nouvel employé est embauché ! ";
echo "Il occupera le poste de $poste";
}
}
$Harry = new employe("Graphiste","Lyon");
|
|
Afin d'illustrer le concept d'héritage, nous allons créer une classe avion contenant les méthodes et propriétés similaires à tout type d'avion, puis deux autres classes planeur et concorde qui héritent de toutes les méthodes et propriétés de la classe avion, mais en ajoutant des propriétés et des méthodes qui leur sont propres.
class avion {
var $nom;
var $pilote;
var $etat = "Au Sol";
function decoller() {
$this->etat = "En vol";
}
function atterrir() {
$this->etat = "Au Sol";
}
function changer_pilote($pilote) {
$this->pilote = $pilote;
}
function changer_nom($nom) {
$this->nom = $nom;
}
function info() {
echo "Le $this->nom piloté ";
echo "par $this->pilote ";
echo "et actuellement $this->etat";
}
}
|
|
class planeur extends avion {
// La classe planeur hérite de toutes les
// méthodes et propriétés de la classe avion
// Mais on peut lui en spécifier d'autres
function infos() {
$this->info();
// info() est décrite dans la classe avion
echo "<BR>C'est un planeur<BR><BR>";
}
}
|
|
class concorde extends avion {
function infos() {
$this->info();
echo "<BR>C'est un concorde<BR><BR>";
}
}
$avion = new concorde;
$avion->changer_pilote("M. JURILE");
$avion->changer_nom("Freleux");
// Nom de l'avion
$avion->infos();
|
|
Affiche :
"Le Freleux est piloté par M. JURILE et actuellement Au Sol.
C'est un concorde."
En résumé, les classes vous permettent d'automatiser certaines tâches.
Elles sont très pratiques dans de gros développements, mais leur utilisation peut se révéler une perte de temps dans une petite application.
A titre d'exemple, voici une classe permettant d'envoyer des e-mails :
<?php
# -------------------------------------------------------------------- #
# Classe email v1 #
# Pour envoyer des mails #
# -------------------------------------------------------------------- #
# Par MiK - pasavalle@ifrance.com #
# -------------------------------------------------------------------- #
# Utilisation: #
# $mail = new email( #
# "Sujet", "Message", "Nom de l'expéditeur", "Email expediteur" #
# Array pour, Array copies, Array copies cachés, "Email reponse"); #
# $mail->env(); #
# -------------------------------------------------------------------- #
# Afin d'éviter de déclarer la classe deux fois, on ne la déclare que si
# la constante 'MAIL_CLASS_DEFINED' n'est pas definie.
if ( ! defined( 'MAIL_CLASS_DEFINED' ) ) {
define( 'MAIL_CLASS_DEFINED', 1 );
# Definition de la classe
class email {
# On declare les variables de cette classe
var $de;
var $replyTo;
var $sujet;
var $message;
var $pour;
var $cc;
var $bcc;
var $headers;
# Puis les fonctions, dont le constructeur :
function email( $sujet, $message, $deNom, $deMail, $pour, $ccList=0,
$bccList=0, $replyTo=0) {
# On affecte une valeur aux variables de la classe avec $this
$this->de = $deNom . " <$deMail>";
$this->replyTo = $replyTo;
$this->sujet = $sujet;
$this->message = $message;
# Si $Pour comporte plusieurs destinataires, on les met bout à bout
# en les séparant par ","
# Ex : array("Email1","Email2","Email3") donne
# "Email1,Email2,Email3"
# Sinon on met juste le nom du seul destinataire
if (is_array($pour)) {
$this->pour = join($pour, "," );
} else {
$this->pour = $pour;
}
# Pareil pour les copies
if (is_array($ccList) && sizeof($ccList)) {
$this->cc = join( $ccList, "," );
} elseif ($ccList) {
$this->cc = $ccList;
}
# Pareil pour les copies cachés
if (is_array($bccList) && sizeof($bccList)) {
$this->bcc = join( $bccList, "," );
} elseif ( $bccList ) {
$this->bcc = $bccList;
}
}
# Cette fonction envoie simplement le mail via la fonction mail() de
# PHP. Mais on aurait pu ajouter des fonctions en plus du type: envoi
# via les SOCKETS ou Verification des emails
function env() {
# On forme la tête de message avec les variables de la classe
# Expéditeur : Nom et email (voir le constructeur)
$this->headers = "From: " . $this->de . "\n";
# Adresse de réponse
if ($this->replyTo) {
$this->headers .= "Reply-To: " . $this->replyTo . "\n";
}
# Copies
if ($this->cc) {
$this->headers .= "Cc: " . $this->cc . "\n";
}
# Copies Cachés
if ($this->bcc) {
$this->headers .= "Bcc: " . $this->bcc . "\n";
}
# Envoi du mail
# On aurait pu se passer du return et ecrire juste mail(...) mais le
# return renvoie le resultat de la fonction mail() ce qui
# permet de tester si le mail a bien été envoyé
return mail($this->to,$this->subject,$this->message,$this->headers);
}
}
# Fin de la classe
}
# Fin du IF permettant d'éviter les erreurs de déclaration
# (C'est à dire de déclarer deux classes ou plus portant le même nom.)
# -------------------------------------------------------------------- #
# - Exemple d'envoi de mail - #
# -------------------------------------------------------------------- #
$msg = "Bonjour Alex, comment vas-tu ?\n";
$msg .= "Ca fait longtemps que je n'ai pas reçu de nouvelles de toi.\n";
$msg .= "Tu passes toujours tes journées à jouer à Age of Empires ?\n";
$msg .= "\n";
$msg .= "A bientôt,\n";
$msg .= "Pierre";
$exp = array( "pasavalle@ifrance.com");
$m = new email("Que deviens-tu ?", $msg, "Pierre",
"pasavalle@ifrance.com", $exp);
$env = $m->env();
if (!$env)
echo "L'envoi a échoué !";
else
echo "Message envoyé !";
# Les paramètres optionels ne sont pas utilisés. (Copies, Copies
# cachées, Adresse de reponse)
?>
|
|
Quelques liens pour aller plus loin.
» Manuel PHP / Les Classes
» Zend - An Introduction to Classes
» PHPBuilder - Object Oriented Programming in PHP
» DevShed - Using PHP classes to navigate distributed whois databases
|
|
