Introduction à PHP objet

Chapitre 5 – Introduction à PHP objet
1. Notions
Classe
Une classe est un type abstrait, c’est un modèle pour créer plusieurs objets concrets présentant des
caractéristiques communes. Elle a un état (propriétés), un comportement (méthodes), et un
constructeur.
Ex : class Humain
Objet
Un objet est une instance d’une classe. Ex : humain1, humain2, …
Propriété ou donnée membre
Caractéristique d'une instance ou d’une classe. Les propriétés sont des variables.
Ex : nom, prenom, sexe (propre à une instance), nombre d’humains (propre à la classe)
Méthode ou fonction membre
Une méthode est une fonction qui manipule une ou plusieurs propriétés d’un objet. Par exemple pour la
classe Humain la méthode age calcule l’âge d’une instance (âge d’un humain donné). On pourrait
également définir en PHP5 un méthode nombre qui retournerait le nombre d’instances de la classe.
Constructeur
Fonction appelée automatiquement lors de la création d’une instance. Le constructeur a le même nom
que la classe en PHP4 (__construct en PHP5). Il peut avoir 0, 1 ou plusieurs arguments.
Ex : Humain($nom, $prenom, $sexe, $habite, $an)
class Humain{
// proprietes (donnees membres)
var $nom;
var $prenom;
var $sexe;
var $ville;
var $annee;
// constructeur
function Humain($nom,
$this->nom
$this->prenom
$this->sexe
$this->ville
$this->annee
}
// Ex de classe en PHP 4
$prenom, $sexe, $habite, $an){
= $nom;
= $prenom;
= $sexe;
= $habite;
= $an;
// methode (fonction membre)
function age(){
return (date("Y") - $this->annee) ;
}
}
©Magali Contensin
avril 2006
1/9
2. Créer et manipuler des instances de classe
2.1 Création
Syntaxe
$instance = new NomClasse();
$instance = new NomClasse(arg1, ..., argN);
Exemple
$client1 = new Humain('Dupond', 'Pierre', 'M', 'Marseille', 1950);
2.2 Accès aux propriétés
Syntaxe
$nom_instance->nom_propriete
Exemple
echo "{$client1->prenom} {$client1->nom}"; // affichera Pierre Dupond
Un objet obj peut être sérialisé (lecture/écriture d’un objet) par session $_SESSION[‘nomobj’].
3. Méthodes
Syntaxe
function nom_fonction(arg1, ..., argN){
// code fonction
}
this
this est utilisé dans les méthode pour faire référence à l’objet en cours (l'instance qui a reçu le
message). Par exemple dans la fonction age $this->annee fournira l’année de naissance de
l’objet pour lequel une demande d’âge a été effectuée.
Envoi de message à l'objet
$nom_instance->nom_methode(arg1, ..., argN)
Exemple
echo "{$client1->prenom} {$client1->nom} a ", $client1->age(), " ans ";
// affichera Pierre Dupond a 56 ans
4. Comparaisons d’objets
PHP 4 : deux instances de la même classe peuvent être comparées avec l’opérateur « == ». Deux
objets sont égaux s’ils ont les mêmes valeurs et les mêmes attributs et s’ils sont des instances de la
même classe.
PHP 5 :
 Opérateur « == » : deux instances sont égales si elles ont les mêmes attributs, les mêmes valeurs et
sont des instances de la même classe
 opérateur « === » : deux objets sont identiques si et seulement si ils réfèrent à la même instance de la
même classe.
©Magali Contensin
avril 2006
2/9
5. Héritage
Une classe peut hériter d’une autre classe (sous-classement). La sous-classe ou classe fille est une
spécialisation de la super-classe (classe mère). La classe fille possède les variables et méthodes de la
super-classe plus des propriétés et méthodes spécifiques. Quand des méthodes sont ajoutées on parlera
d’enrichissement. Lorsqu’une méthode de même signature est réécrite dans la classe fille on parlera de
redéfinition.
Les classes filles doivent toujours être définies après la super-classe.
PHP propose un héritage simple : une classe hérite d’une et une seule classe. Mais il est possible de
simuler l’héritage multiple avec des interfaces comme en Java.
class Transport {
var $consommation;
var $vitesse;
var $nb_voyageurs;
function duree($km){
// calcul de la duree du trajet
}
function consomme($km){
// calcul de la consommation
}
}
class Voiture extends Transport{
var $marque_pneus;
function dist_freinage($vitesse, $etat_sol){
// calcul de la distance de freinage
}
}
class Voilier extends Transport{
var $nb_voiles;
function portance($incidence, $corde, $hauteur, $vitesse_vent){
// calcul de la portance
}
}
Opérateur de résolution de portée ::
Cet opérateur permet d’accéder aux variables de classes et aux constantes de classe. Il permet aussi
d’appeler le constructeur d’une super-classe ou ses méthodes quand il y a redéfinition.
parent
parent permet de faire référence à une propriété ou une méthode de la super-classe. Plutôt que d’utiliser
le nom de la classe mère dans le code on utilise parent qui fait référence au nom qui apparaît dans le
« extends » :
parent::nom_methode(args)
©Magali Contensin
avril 2006
3/9
6. Fonctionnalités spécifiques à PHP 5
 Visibilité des données membres :
o public (accès public),
o protected (accès limité aux classes filles et mères),
o private (accès uniquement dans la classe).
Attention il n’y a plus de déclaration var en PHP 5.
 Visibilité des fonctions membres :
o public
o protected
o private
Par défaut une méthode est créée avec une visibilité publique.
 Propriétés et méthodes de classe (mot clé static). Un membre statique ou une méthode statique
peut être accédé sans instanciation de la classe. Un membre statique est accédé par une méthode
statique. Il ne peut y avoir de pseudo-variable $this dans une méthode statique (car elle est
appelée sans instance de l’objet). De même on ne peut pas accéder aux propriétés statiques avec
le nom de l’objet suivi de ->. Il faut utiliser l’opérateur :: et le nom de la classe ou self.
 Constantes de classes : const nom_constante = valeur_constante;
Une constante n’a pas de $ devant son nom. Elle ne peut pas être accédée directement par un
objet. La visibilité est publique. Humain::doigts.
 Finalisation : __destruct()
 final : une classe fille ne peut pas redéfinir une méthode si dans la classe mère la méthode est
« final ». Il est impossible d’hériter d’une classe qui est préfixée par le mot-clé final.
 Classes et méthodes abstraites. Une classe abstraite (mot clé abstract) ne peut pas être
instanciée. Toute classe comportant au moins une méthode abstraite est une classe abstraite.
Une méthode abstraite contient simplement la signature. Une classe qui héritera de la classe
abstraite devra définir toute méthode abstraite (l’implémentation de la méthode est faite par la
classe fille). Par exemple, la classe Transport devrait être déclarée abstraite car c’est une
classe qui ne doit pas avoir d’instances. Ce sont ses classes dérivées (voiture, voilier, train, …)
qui seront instanciées.
 Interface. Une interface (mot-clé interface) est une spécification : elle fixe la liste des
méthodes qu’on est certain de trouver dans toute classe qui déclare être conforme à la
spécification. L’interface spécifie quelles méthodes une classe devra implémenter (seules les
signatures sont données). Toutes les méthodes de l’interface sont publiques. Lorsqu’on
implémente une interface (mot clé implem ents) il faut définir toutes les méthodes.
 Surcharge avec __call, __get et __set
 Parcourir un objet : il est possible d’obtenir toutes les propriétés visibles d’un objet avec un
foreach.
 Clonage : le mot-clé clo ne permet de créer une copie de l’objet.
 Introspection (réflexion) : possibilité d’apprendre des informations sur toute classe (reverse
engineering).
©Magali Contensin
avril 2006
4/9
<?php
// fichier humain.php
class Humain{
// donnees membres
private $nom;
// variables d'instance
private $prenom;
private $sexe;
private $ville;
private $annee;
private static $nb = 0; // variable de classe
const doigts = 5;
// constante de classe
// constructeur
function construct($nom, $prenom, $sexe, $habite, $an){
$this->nom
= $nom;
$this->prenom
= $prenom;
$this->setSexe($sexe);
$this->ville
= $habite;
$this->setAnnee($an);
self::$nb++;
}
// accesseurs
function getNom()
{
function getPrenom(){
function getSexe() {
function getVille() {
function getAnnee() {
return
return
return
return
return
$this->nom; }
$this->prenom; }
$this->sexe; }
$this->ville;}
$this->annee; }
// modificateurs
function setAnnee($annee){
if (($annee > 1900) && ($annee < date("Y"))){
$this->annee = $annee;
}
else{ echo "annee $annee non valide pour $this->nom<br>"; }
}
function setSexe($sexe){
if (($sexe == 'M') || ($sexe == 'F')){
$this->sexe = $sexe;
}
else{ echo "sexe $sexe incorrect pour $this->nom<br>"; }
}
// fonction membre (methode d'instance)
function age(){
if ($this->annee != 0){
return (date("Y") - $this->annee) ;
}
else{
return "undefined"; }
}
// fonction membre (methode de classe)
function nombre(){
return self::$nb;
}
}
?>
©Magali Contensin
avril 2006
5/9
<?php
// inclusion de la classe Humain
require("humain.php");
// creation d'instances de la classe
$liste[] = new Humain('Dupond', 'Pierre', 'M', 'Marseille', 1950);
$liste[] = new Humain('Gantt', 'Paul', 'M', 'Paris', 1970);
$liste[] = new Humain('Dujardin', 'Anne', 'F', 'Bordeaux', "azer");
$liste[] = new Humain('Armand', 'Ludovic', 'x', 'Toulous', 1995);
// modification d'une propriete d'une instance
$liste[1]->setAnnee(2007);
// affichage des instances
echo "<br>Liste :<br>";
foreach ($liste as $client){
echo "- {$client->getPrenom()} {$client->getNom()} a ",
$client->age(), " ans<br>";
}
// affichage des donnees de classe
echo "<br>il y a ", Humain::nombre(), " humains<br>";
echo "un humain a ", Humain::doigts, " doigts par main";
?>
annee azer non valide pour Dujardin
sexe x incorrect pour Armand
annee 2007 non valide pour Gantt
Liste :
- Pierre Dupond a 56 ans
- Paul Gantt a 36 ans
- Anne Dujardin a undefined ans
- Ludovic Armand a 11 ans
il y a 4 humains
un humain a 5 doigts par main
©Magali Contensin
avril 2006
6/9
7. Résumé et choix (PHP 5)
Programmer objet c’est définir des classes, leurs données et comment elles communiquent.
données membres
variables d’instances
variables de classes
static
état
constantes de classes
const
classe
type abstrait
fonctions membres
comportement
constructeur
Initialiser les données
accesseurs
modificateurs
accès aux variables d’instances ou
aux variables de classe
static
méthodes d’instances
méthodes de classes
fonctions privées
private
méthodes de finalisation
__destruct
7.1 Données membres d’une classe (attributs ou propriétés)
a) Variable de classe ou variable d’instance ?
-
-
La donnée varie selon l’instance  variable d’instance
o une copie de la variable par objet, la copie est initialisée lors de l’instanciation de la
classe
o ex : couleur des cheveux pour un objet Humain
La donnée est partagée par tous les objets de la classe  variable de classe
o un seul exemplaire de la variable auquel toutes les instances accèdent : une seule copie
initialisée lors de la création de la classe (toutes les instances de la classe voient la même
valeur) ~ variable globale en C
o ex : compteur du nombre d’instances de la classe (nombre d’humains)
b) Variable locale à une méthode ou variable d’instance de la classe ?
-
propriétés de l’objet  variables d’instances
o déclarées en dehors de toute méthode
o ex : couleur des cheveux, nom, prénom, date de naissance
si la variable doit être utilisée par plusieurs méthodes de la classe  var. d’instance
sinon variable locale à la méthode
o ex : calcul de l’age (on peut utiliser une variable locale pour stocker la date du jour)
c) Constante de classe ?
-
la valeur de la constante est partagée par tous les objets de la classe  constante de classe
o proche du #define du C
o ex : nombre de doigts d’un humain
d) Quelle protection d’accès pour les données membres (hors constantes) ?
`
mot-clé
public
protected
private
Visibilité
lecture/écriture dans tout le script
lecture/écriture pour les super-classes et les classes dérivées directes ou indirectes
lecture/écriture uniquement au sein de la classe.
©Magali Contensin
avril 2006
7/9
-
-
les variables d’instance doivent autant que possible être private (toute donnée membre qui
peut être rendue privée doit l’être)
o lecture par accesseur
o modification par modificateur
 avantage = on peut modifier en contrôlant la validité de la modification,
cohérence interne des données (nombre compris entre deux bornes, nombres
positifs, …)
 implémentation masquée, si des modifications ont lieu dans la classe, comme le
changement d’un type de données, il est inutile de réécrire les classes qui
l’utilisent.
exceptionnellement accès public à une variable d’instance ou de classe (plus que déconseillé)
o avantage = accès plus rapide (on ne passe pas par un accesseur)
o possible uniquement s’il n’y a pas possibilité d’affecter des données aberrantes
7.2 Fonctions membres d’une classe (comportements)
Les différentes méthodes d’une classe :
- constructeur : initialisation de l’instance ;
- méthodes permettant l’accès ou la manipulation des données membres depuis l’extérieur
o accesseurs -> public
o modificateurs -> public
- méthodes d’instances réalisent des opérations sur des variables d’instances (calcul de l’âge) ;
- méthode de classe = méthode qui ne dépend pas de l’instance ;
- méthodes redéfinies = méthodes de même signature que la méthode de la super-classe
(spécialisation d’une méthode de la classe mère) ;
- méthodes privées = sous programmes qui sont des outils pour d’autres méthodes de la classe ;
- destructeur (finalisation lors de la destruction de l’objet).
a) Constructeur
-
Méthode qui permet de fixer l’état initial de l’objet (propriétés)
Porte toujours le même nom que la classe ou __construct en PHP5
Appelé directement par PHP lors d’un new.
Permet de définir les valeurs initiales des variables d’instance, d’appeler des méthodes, etc.
Pas de surcharge des méthodes constructeurs = un constructeur par classe, mais on peut donner
des valeurs par défaut à des arguments
On peut appeler une méthode constructeur de la super-classe depuis un constructeur de la classe
fille avec parent::NomConstructeur(arguments) ou parent::__construct
(PHP5). L’appel au constructeur de la super-classe n’est jamais fait automatiquement.
b) Méthode de classe ou méthode d’instance ?
-
-
méthode d’intérêt général pas dépendante d’une instance de la classe  méthode de classe
o l’envoi de message n’est pas destiné à l’instance mais à la classe ($this n’est pas défini)
o manipule uniquement des variables de classe et peut utiliser d’autres méthodes de classe
o ex. méthode qui incrémente ou décrémente le nombre d’humains
méthode d’instance
o manipule des variables d’instance
o ex. méthode qui calcule l’âge d’un humain
c) Finalisation
Méthode appelée juste avant que l’objet soit détruit.
function __destruct(){
parent::__destruct();
}
d) Méthode final ?
Si la méthode est final elle ne pourra pas être redéfinie dans une sous-classe. Les méthodes privées
sont implicitement final.
©Magali Contensin
avril 2006
8/9
e) Méthode abstraite ?
-
Méthode à redéfinir obligatoirement dans les classes dérivées (si une classe contient une méthode
abstraite, elle doit elle-même être abstract).
Ne comporte aucune implémentation = juste une signature : abstract function age();
f) Quelle protection d’accès pour les fonctions membres ?
mot-clé
public
protected
private
visibilité
Appel dans tout le script (par défaut)
Appel depuis la classe ou une classe dérivée
Appel restreint à la classe. La méthode ne sera pas héritée par une sous-classe
7.3 Classes
a) Classe ou classe fille ?
La sous-classe ou classe fille est une spécialisation de la super-classe (classe mère). Une classe fille
comporte toutes les données et méthodes de la classe mère plus les siennes.
b) Classe abstraite ?
-
Aucune instance
Classe en haut de la hiérarchie d’héritage qui définit des comportements et données communs à
toutes les classes.
c) Classe finale ?
Aucune classe ne pourra être dérivée.
La visibilité des classes est publique.
8. Exceptions (PHP 5)
Intercepter toutes les exceptions
try{
// code ou une exception peut etre levee
} catch(Exception $e){
// traitement en cas d'exception
}
Lever une exception
throw expression;
Créer sa classe exception
Class MonException extends Exception
{
public function __construct($message, $code = 0) {}
// traitement specifique
…
parent::__construct($message, $code);
}
©Magali Contensin
avril 2006
9/9