Introduction : qu'est-ce qu'une classe ?
Les classes sont, comme les fonctions, des dispositifs permettant la réutilisation du code,
mais le système des classes est extrêmement plus sofistiqué. Les caractéristiques les
plus importantes sont :
- Une "classe" est un ensemble d'éléments de programmes beaucoup plus complet
qu'une simple fonction, elle englobe des déclarations, des fonctions, des calculs...
rassemblés dans une classe afin de réaliser une tache spécifique.
- Lorsque plusieurs programmes séparés utilisent une même classe, ils utilisent
en fait chacun une "instance" de cette classe, donc il n'y a pas de risque d'interférence
entre ces différents programmes, principalement au niveau des variables, chacun
pouvant manipuler indépendemment chaque variable de son instance de classe.
- Lorsqu'un programme a créé une instance de classe, il a à sa portée tous les
éléments de la classe, certains s'exécutant automatiquement lors de l'appel,
d'autres devant être activés spécifiquement, au moment voulu par le programmeur
- Les fonctions qui composent la classe (méthodes) peuvent être soient exécutées
telles qu'elles sont dans la classe, ou peuvent être modifiées (surchargées)
par le programme qui les appelle (PHP5)
- Une classe peut faire appel à une autre classe et ainsi de suite (héritage),
il y a souvent une notion de hiérarchie dans les classes.
Anatomie d'une classe
| Code | Commentaires |
|---|
<?php
class maClasse
{ |
|
var $maPropriété_1
var $maPropriété_2
. . . . . . . |
|
function maClasse
{
code
}
|
|
function mamaMéthode(paramètre_1, paramètre_2...)
{
code de la fonction;
}
|
|
. . . . lignes de code quelconques;
this -> maMéthode(param_1, param_2)
|
|
. . . . lignes de code quelconques;
this -> maPropriété_1 = "vert"
|
|
}
?> |
|
Anatomie d'un programme utilisant une classe
| Code | Commentaires |
|---|
<?php
monObjet = new maClasse ; |
|
<?php
monObjet -> maMéthode(param_1, param_2...) ; |
|
<?php
monObjet -> maPropriété_1 = "bleu" ; |
|
Notre première classe
Nom du fichier : exercises_08/lesson_08_add.php
Les objets
Une fois qu'une classe a été définie, PHP vous permet d'engendrer autant d'instance de la classe
que vous voudrez. Ces instances d'une classe sont dites des "
objects".
Chacune de ces instances est un objet complètement indépendant, avec ses propres propriétés et méthodes,
et peut être remodelé ainsi indépendamment d'autres instances.
Ceci est interessant dans les cas où vous devez engendrer plus d'une instance d'un objet - par exemple,
de deux liens simultanés de base de données pour deux requetes simultanées. Les classes vous aident
également à séparer votre code dans les modules indépendants, et simplifient de ce fait
l'entretien et les changements de code.
Un exemple un peu plus complexe
On se propose de construire une classe de validation de formulaire.
Cette classe va rassembler toute une panoplie de méthodes permettant de tester
les données saisies par l'utilisateur.
- Vérification de date mois compris entre 1 et 12 , jour , année ..
- Vérification de la cohérence pour un patronyme (nom de famille) pas de chiffres...
- Vérification de cohérence pour une adresse email
- Vérification de cohérence pour un age ....
Ainsi à chaque nouveau formulaire il suffira d'aller puiser dans la classe les
méthodes de validation adéquates.
La classe va consister en
1. Une série de méthodes qui acceptent les données à valider comme arguments de méthode,
examine ces données pour voir si elles sont valides et renvoie un code et / ou un messge
approprié au résultat de la validation
2. Une structure PHP (ici, un tableau associatif) : liste de toutes les erreurs
rencontrées pendant le procédé de validation, et des méthodes pour manoeuvrer cette structure.
Il est important de noter, cependant, que ces méthodes n'auront rien à faire avec la présentation
visuelle du formulaire ou de la page du résultat du formulaire; plutôt,
ils fournissent un moyen simple pour effectuer la validation des données saisies dans le formulaire.
Pour illustrer le principe, l'exemple suivant va constituer un embryon
de ce que nous voulons faire. Pour commencer simple :
- Nous aurons encore la classe et le formulaire dans le même fichier.
Dans les exemples suivants le formulaire et la classe seront dans des fichiers séparés
- Un seul fichier aussi pour le formulaire et son traitement (PHP_SELF)
- Un seul champ de formulaire
- Une seule méthode simple de validation
Nom du fichier : exercises_08/lesson_08_form_1.php
Résumé des paragraphes précédents :
Organisation des fichiers :
En fait il faut pas moins de 5 fichiers pour réaliser un formulaire qui soit élégant (feuille de style),
modulaire , donc facile à modifier (classes), stable, pratique à utiliser (messages d'erreur appropriés
à chaque erreur de saisie, rechargement automatique des données saisies) :
Pour plus de simplicté tous les fichiers sont réunis dans le même répertoire
En fait dans la réalité ce n'est pas le cas, pour un site réel, il y a plutôt un répertoire
pour les classes, un autre pour feuilles de style...
Nom du premier fichier : exercises_08/lesson_08_form_2.php
L'héritage
On dit qu'une classe hérite d'une autre classe lorsque elle possède en elle
touts les composants (méthodes, variables...) d'une autre classe.
Contrairement au système de fonctions qui permet d'appeler une fonction à l'intérieur
d'une autre fonction, avec la syntaxe normale d'appel de fonction, le système d'héritage
fonctionne au moyen d'un mot-clé spécial extends à utiliser
uniquement lors de la déclaration de la classe.
Ainsi lorsque on veut mettre en place une classe qui hérite d'une autre classe, on va écrire
<?php
class nouvelleClasse extends ancienneClasse
{
. . . .
}
?>
La classe nouvelleClasse va hériter de tous les composants
de la classe ancienneClasse
Tous les constructeurs des classes parentes vont s'executer lors de l'instantiation de la classe fille :
Un exemple très simple pour illustrer l'hériage
Nom du fichier : exercises_08/lesson_08_heritage.php
Anticipation leçon mySQL : Exemple avec héritage : Lecture d'une table
Nom du fichier : exercises_08/lesson_08_db_lecture.php
Anticipation leçon mySQL : Exemple avec héritage : Ecriture dans une table
Nom du fichier : exercises_08/lesson_08_db_ajout.php
Anticipation leçon mySQL : Exemple avec héritage : Effacement dans une table
Nom du fichier : exercises_08/lesson_08_db_efface.php
L'opérateur ::
L'opérateur :: est utilisé à la place de -> pour se referrer à des fonctions
et variables de la classe de base ou à des fonctions qui appartiennent
à des classes qui n'ont pas encore d'instances.
Dans l'exemple ci-après, on appelle la fonction example(), mais il n'y a aucun objet
créé à partir de la classe A, aussi nous ne pouvons pas écrire $a->example(), c'est pourquoi
nous appelons example() comme une 'fonction de classe', c'est à dire une fonction de la classe elle-même,
et pas un objet résultant de l'instantiation de la classe.
Une "fonction de classe" ne peut utiliser aucune variable d'objet (ne peut utiliser $this)
La classe B redéfinit la fonction example(), la définition originale (classe A) devient cachée
et n'est plus disponible, à moins que vous n'utilisiez l'opérateur :: pour y accéder.
Les opérateurs :: et => (PHP4 et 5)
Nom du fichier : exercises_08/lesson_08_operators.php
Nouveautés PHP5 relatives aux classes
- Constructeurs/destructeurs : comme indiqué ci-dessus l'appel de la classe provoque
l'execution du constructeur. Par contre le destructeur doit être appelé spécifiquement
et il permet de libérer la partie mémoire utilisée par l'objet lorsque celui-ci
n'est plus necessaire.
- Constructeurs : ils peuvent être appelés par le mot-clé __construct()
- Constructeurs : ils peuvent être appelés par le mot-clé __destruct()
Constructeurs et destructeurs
Nom du fichier : exercises_08/lesson_08_php_5_constructeurs.php
Les objets sont passés par référence par défaut, et non plus par valeur
Les methodes peuvent être surchargées, sauf celles qui sont déclarées "final"
Gestion des exeptions (mots-clés "try" , "catch", "throw") : voir à la fin du chapitre 11
PHP5 : Variables de classes privées et protégées
Le moteur Zend 2.0 introduit les variables privées et protégées :
Les variables de classes protégées peuvent être accédées par les classes
dérivées des classes dans lesquelles elles sont protégées , tandis que les
variables de classes privées ne peuvent être utilisées que dans les
classes dans lesquelles elles sont déclarées (sauf accès direct avec l'opérateur ::).
Les variables de classe en php5
Nom du fichier : exercises_08/lesson_08_php_5_variables_de_classe.php
PHP5 : Méthodes privées, protégées
Le concept est le même que pour les variables (voir ci-dessus)
Méthodes privées, protégées
Nom du fichier : exercises_08/lesson_08_php_5_methodes_privees.php
PHP5 : Classes et methodes abstraites
Les classes abstraites sont des classes qui ne peuvent pas être instanciées.
Elles peuvent donc être seulement "étendues" au moyen de l'héritage.
Une méthode abstraite ne peut être déclarée que dans une classe abstraite et ne
peut contenir de code mais seulement des commentaires (signature).
Une classe qui contient une methode abstraite doit être déclarée abstraite elle-même
Classes et methodes abstraites
Nom du fichier : exercises_08/lesson_08_php_5_classes_abstraites.php
PHP5 : Les interfaces
Une classe abstraite peut contenir des methodes abstraites et des méthodes
non-abstraites. Une interface est une classe qui ne contient que des methodes abstraites.
Les interfaces sont donc toujours abstraites, sans qu'il soit necessaire de l'indiquer;
il n'est pas non plus necessaire de déclarer leurs methodes comme étant abstraites.
Dans le cas des interfaces, le mot-clé "implements" , qui remplace "extends",
peut être suivi de plusieurs noms d'interfaces, contrairement à "extends" qui ne peut être
suivi que d'un seul non de classe
Interfaces
Nom du fichier : exercises_08/lesson_08_php_5_interfaces.php
 |
| Tous droits réservés. 2005-2020
 |
|
