Programmez en orienté objet en PHP - Site du Zéro

Programmez en orienté objet en PHP Par Victor Thuillier (vyk12)

www.openclassrooms.com

Licence Creative Commons 6 2.0 Dernière mise à jour le 8/01/2013

2/333

Sommaire Sommaire ........................................................................................................................................... 2 Lire aussi ............................................................................................................................................ 5 Programmez en orienté objet en PHP ............................................................................................... 7 Ce qui doit être acquis ....................................................................................................................................................... 7

Partie 1 : [Théorie] Les bases de la POO ........................................................................................... 8 Introduction à la POO ........................................................................................................................................................ 8 Qu'est-ce que la POO ? .............................................................................................................................................................................................. 8 Il était une fois le procédural ....................................................................................................................................................................................... 8 Puis naquit la programmation orientée objet ............................................................................................................................................................... 8 Exemple : création d'une classe .................................................................................................................................................................................. 9 Le principe d'encapsulation ......................................................................................................................................................................................... 9 Créer une classe ....................................................................................................................................................................................................... 10 Syntaxe de base ........................................................................................................................................................................................................ 10 Visibilité d'un attribut ou d'une méthode .................................................................................................................................................................... 10 Création d'attributs .................................................................................................................................................................................................... 10 Création de méthodes ............................................................................................................................................................................................... 11 En résumé ................................................................................................................................................................................................................. 12

Utiliser la classe .............................................................................................................................................................. 13 Créer et manipuler un objet ....................................................................................................................................................................................... 13 Créer un objet ............................................................................................................................................................................................................ 13 Appeler les méthodes de l'objet ................................................................................................................................................................................ 13 Accéder à un élément depuis la classe ..................................................................................................................................................................... 14 Implémenter d'autres méthodes ................................................................................................................................................................................ 15 Exiger des objets en paramètre ................................................................................................................................................................................ 17 Les accesseurs et mutateurs .................................................................................................................................................................................... 18 Accéder à un attribut : l'accesseur ............................................................................................................................................................................ 18 Modifier la valeur d'un attribut : les mutateurs ........................................................................................................................................................... 19 Retour sur notre script de combat ............................................................................................................................................................................. 21 Le constructeur .......................................................................................................................................................................................................... 22 L'auto-chargement de classes .................................................................................................................................................................................. 24 En résumé ................................................................................................................................................................................................................. 26

L'opérateur de résolution de portée ................................................................................................................................ 26 Les constantes de classe .......................................................................................................................................................................................... Les attributs et méthodes statiques .......................................................................................................................................................................... Les méthodes statiques ............................................................................................................................................................................................ Les attributs statiques ............................................................................................................................................................................................... En résumé .................................................................................................................................................................................................................

27 29 29 31 32

Manipulation de données stockées ................................................................................................................................. 33 Une entité, un objet ................................................................................................................................................................................................... 34 Rappels sur la structure d'une BDD .......................................................................................................................................................................... 34 Travailler avec des objets .......................................................................................................................................................................................... 34 L'hydratation .............................................................................................................................................................................................................. 38 La théorie de l'hydratation ......................................................................................................................................................................................... 38 L'hydratation en pratique ........................................................................................................................................................................................... 39 Gérer sa BDD correctement ...................................................................................................................................................................................... 44 Une classe, un rôle ................................................................................................................................................................................................... 44 Les caractéristiques d'un manager ........................................................................................................................................................................... 45 Les fonctionnalités d'un manager .............................................................................................................................................................................. 45 Essayons tout ça ! ..................................................................................................................................................................................................... 47 En résumé ................................................................................................................................................................................................................. 48

TP : Mini-jeu de combat .................................................................................................................................................. 49 Ce qu'on va faire ....................................................................................................................................................................................................... 50 Cahier des charges ................................................................................................................................................................................................... 50 Notions utilisées ........................................................................................................................................................................................................ 50 Pré-conception .......................................................................................................................................................................................................... 50 Première étape : le personnage ................................................................................................................................................................................ 51 Les caractéristiques du personnage ......................................................................................................................................................................... 51 Les fonctionnalités d'un personnage ......................................................................................................................................................................... 51 Les getters et setters ................................................................................................................................................................................................. 53 Hydrater ses objets ................................................................................................................................................................................................... 55 Codons le tout ! ......................................................................................................................................................................................................... 55 Seconde étape : stockage en base de données ....................................................................................................................................................... 57 Les caractéristiques d'un manager ........................................................................................................................................................................... 58 Les fonctionnalités d'un manager .............................................................................................................................................................................. 58 Codons le tout ! ......................................................................................................................................................................................................... 59 Troisième étape : utilisation des classes ................................................................................................................................................................... 61 Améliorations possibles ............................................................................................................................................................................................ 71

L'héritage ......................................................................................................................................................................... 72 Notion d'héritage ....................................................................................................................................................................................................... Définition ................................................................................................................................................................................................................... Procéder à un héritage .............................................................................................................................................................................................. Surcharger les méthodes .......................................................................................................................................................................................... Héritez à l'infini ! ........................................................................................................................................................................................................ Un nouveau type de visibilité : protected ..................................................................................................................................................................


73 73 74 75 76 78

Sommaire

3/333

Imposer des contraintes ............................................................................................................................................................................................ Abstraction ................................................................................................................................................................................................................ Finalisation ................................................................................................................................................................................................................ Résolution statique à la volée ................................................................................................................................................................................... Cas complexes .......................................................................................................................................................................................................... Utilisation de static:: dans un contexte non statique ................................................................................................................................................. En résumé .................................................................................................................................................................................................................

79 79 81 82 85 89 90

TP : Des personnages spécialisés .................................................................................................................................. 90 Ce que nous allons faire ........................................................................................................................................................................................... 91 Cahier des charges ................................................................................................................................................................................................... 91 Des nouvelles fonctionnalités pour chaque personnage ........................................................................................................................................... 91 La base de données .................................................................................................................................................................................................. 91 Le coup de pouce du démarrage .............................................................................................................................................................................. 92 Correction .................................................................................................................................................................................................................. 93 Améliorations possibles .......................................................................................................................................................................................... 104

Les méthodes magiques ............................................................................................................................................... 105 Le principe ............................................................................................................................................................................................................... 105 Surcharger les attributs et méthodes ...................................................................................................................................................................... 105 « __set » et « __get » .............................................................................................................................................................................................. 105 « __isset » et « __unset » ....................................................................................................................................................................................... 108 Finissons par « __call » et « __callStatic » .............................................................................................................................................................. 111 Linéariser ses objets ................................................................................................................................................................................................ 113 Posons le problème ................................................................................................................................................................................................. 113 « serialize » et « __sleep » ...................................................................................................................................................................................... 114 « unserialize » et « __wakeup » .............................................................................................................................................................................. 115 Autres méthodes magiques ..................................................................................................................................................................................... 116 « __toString » .......................................................................................................................................................................................................... 116 « __set_state » ........................................................................................................................................................................................................ 117 « __invoke » ............................................................................................................................................................................................................ 118 En résumé ............................................................................................................................................................................................................... 118

Partie 2 : [Théorie] Techniques avancées ....................................................................................... 120 Les objets en profondeur .............................................................................................................................................. 120 Un objet, un identifiant ............................................................................................................................................................................................ Comparons nos objets ............................................................................................................................................................................................ Parcourons nos objets ............................................................................................................................................................................................ En résumé ...............................................................................................................................................................................................................

120 122 125 127

Les interfaces ................................................................................................................................................................ 127 Présentation et création d'interfaces ....................................................................................................................................................................... 128 Le rôle d'une interface ............................................................................................................................................................................................. 128 Créer une interface .................................................................................................................................................................................................. 128 Implémenter une interface ...................................................................................................................................................................................... 128 Les constantes d'interfaces ..................................................................................................................................................................................... 130 Hériter ses interfaces .............................................................................................................................................................................................. 130 Interfaces prédéfinies .............................................................................................................................................................................................. 131 L'interface Iterator ................................................................................................................................................................................................... 131 L'interface SeekableIterator .................................................................................................................................................................................... 133 L'interface ArrayAccess ........................................................................................................................................................................................... 134 L'interface Countable .............................................................................................................................................................................................. 137 Bonus : la classe ArrayIterator ................................................................................................................................................................................ 140 En résumé ............................................................................................................................................................................................................... 141

Les exceptions .............................................................................................................................................................. 141 Une différente gestion des erreurs .......................................................................................................................................................................... 142 Lancer une exception .............................................................................................................................................................................................. 142 Attraper une exception ............................................................................................................................................................................................ 143 Des exceptions spécialisées ................................................................................................................................................................................... 145 Hériter la classe Exception ...................................................................................................................................................................................... 145 Emboîter plusieurs blocs catch ............................................................................................................................................................................... 147 Exemple concret : la classe PDOException ............................................................................................................................................................ 148 Exceptions pré-définies ........................................................................................................................................................................................... 149 Gérer les erreurs facilement .................................................................................................................................................................................... 150 Convertir les erreurs en exceptions ......................................................................................................................................................................... 150 Personnaliser les exceptions non attrapées ........................................................................................................................................................... 151 En résumé ............................................................................................................................................................................................................... 152

Les traits ........................................................................................................................................................................ 152 Le principe des traits ............................................................................................................................................................................................... 153 Posons le problème ................................................................................................................................................................................................ 153 Résoudre le problème grâce aux traits ................................................................................................................................................................... 153 Utiliser plusieurs traits ............................................................................................................................................................................................. 155 Méthodes de traits vs. méthodes de classes .......................................................................................................................................................... 156 Plus loin avec les traits ............................................................................................................................................................................................ 157 Définition d'attributs ................................................................................................................................................................................................. 157 Traits composés d'autres traits ................................................................................................................................................................................ 158 Changer la visibilité et le nom des méthodes .......................................................................................................................................................... 159 Méthodes abstraites dans les traits ......................................................................................................................................................................... 160 En résumé ............................................................................................................................................................................................................... 161

L'API de réflexivité ......................................................................................................................................................... 161 Obtenir des informations sur ses classes ............................................................................................................................................................... Informations propres à la classe ............................................................................................................................................................................. Les relations entre classes ...................................................................................................................................................................................... Obtenir des informations sur les attributs de ses classes ....................................................................................................................................... Instanciation directe ................................................................................................................................................................................................


162 162 164 166 166

Sommaire

4/333

Récupération d'attribut d'une classe ....................................................................................................................................................................... Le nom et la valeur des attributs ............................................................................................................................................................................. Portée de l'attribut ................................................................................................................................................................................................... Les attributs statiques ............................................................................................................................................................................................. Obtenir des informations sur les méthodes de ses classes .................................................................................................................................... Création d'une instance de ReflectionMethod ......................................................................................................................................................... Publique, protégée ou privée ? ............................................................................................................................................................................... Abstraite ? Finale ? ................................................................................................................................................................................................. Constructeur ? Destructeur ? .................................................................................................................................................................................. Appeler la méthode sur un objet ............................................................................................................................................................................. Utiliser des annotations ........................................................................................................................................................................................... Présentation d'addendum ....................................................................................................................................................................................... Récupérer une annotation ....................................................................................................................................................................................... Savoir si une classe possède telle annotation ........................................................................................................................................................ Une annotation à multiples valeurs ......................................................................................................................................................................... Des annotations pour les attributs et méthodes ...................................................................................................................................................... Contraindre une annotation à une cible précise ...................................................................................................................................................... En résumé ...............................................................................................................................................................................................................

167 167 168 169 170 170 171 172 172 173 174 174 175 176 177 178 179 180

UML : présentation (1/2) ................................................................................................................................................ 180 UML, kézako ? ........................................................................................................................................................................................................ 181 Modéliser une classe ............................................................................................................................................................................................... 182 Première approche .................................................................................................................................................................................................. 182 Exercices ................................................................................................................................................................................................................. 183 Modéliser les interactions ........................................................................................................................................................................................ 184 L'héritage ................................................................................................................................................................................................................. 184 Les interfaces .......................................................................................................................................................................................................... 184 L'association ............................................................................................................................................................................................................ 185 L'agrégation ............................................................................................................................................................................................................. 186 La composition ........................................................................................................................................................................................................ 186 En résumé ............................................................................................................................................................................................................... 186

UML : modélisons nos classes (2/2) ............................................................................................................................. 187 Ayons les bons outils ............................................................................................................................................................................................... 188 Installation ............................................................................................................................................................................................................... 188 Installation de l'extension uml2php5 ....................................................................................................................................................................... 188 Lancer Dia ............................................................................................................................................................................................................... 188 Deux zones principales ........................................................................................................................................................................................... 189 Unir les fenêtres ...................................................................................................................................................................................................... 189 Modéliser une classe ............................................................................................................................................................................................... 190 Créer une classe ..................................................................................................................................................................................................... 190 Modifier notre classe ............................................................................................................................................................................................... 190 Modéliser les interactions ........................................................................................................................................................................................ 196 Création des liaisons ............................................................................................................................................................................................... 196 Exercice ................................................................................................................................................................................................................... 199 Exploiter son diagramme ........................................................................................................................................................................................ 199 Enregistrer son diagramme ..................................................................................................................................................................................... 199 Exporter son diagramme ......................................................................................................................................................................................... 201 En résumé ............................................................................................................................................................................................................... 202

Les design patterns ....................................................................................................................................................... 202 Laisser une classe créant les objets : le pattern Factory ........................................................................................................................................ Le problème ............................................................................................................................................................................................................ Exemple concret ..................................................................................................................................................................................................... Écouter ses objets : le pattern Observer ................................................................................................................................................................. Le problème ............................................................................................................................................................................................................ Exemple concret ..................................................................................................................................................................................................... Séparer ses algorithmes : le pattern Strategy ......................................................................................................................................................... Le problème ............................................................................................................................................................................................................ Exemple concret ..................................................................................................................................................................................................... Une classe, une instance : le pattern Singleton ...................................................................................................................................................... Le problème ............................................................................................................................................................................................................ Exemple concret ..................................................................................................................................................................................................... L'injection de dépendances ..................................................................................................................................................................................... Pour conclure .......................................................................................................................................................................................................... En résumé ...............................................................................................................................................................................................................

203 203 204 204 204 207 209 209 209 213 213 214 214 217 217

TP : un système de news .............................................................................................................................................. 218 Ce que nous allons faire ......................................................................................................................................................................................... Cahier des charges ................................................................................................................................................................................................. Retour sur le traitement des résultats ..................................................................................................................................................................... Correction ................................................................................................................................................................................................................ Diagramme UML ..................................................................................................................................................................................................... Le code du système ................................................................................................................................................................................................

219 219 219 221 221 221

Partie 3 : [Pratique] Réalisation d'un site web ................................................................................. 233 Description de l'application ........................................................................................................................................... 234 Une application, qu'est ce que c'est ? ..................................................................................................................................................................... Le déroulement d'une application ........................................................................................................................................................................... Un peu d'organisation ............................................................................................................................................................................................. Les entrailles de l'application .................................................................................................................................................................................. Retour sur les modules ........................................................................................................................................................................................... Le back controller de base ...................................................................................................................................................................................... La page ................................................................................................................................................................................................................... L'autoload ................................................................................................................................................................................................................ Résumé du déroulement de l'application ................................................................................................................................................................

234 234 236 237 237 238 239 240 241

Développement de la bibliothèque ................................................................................................................................ 243


Sommaire

5/333

L'application ............................................................................................................................................................................................................ L'application ............................................................................................................................................................................................................ La requête du client ................................................................................................................................................................................................. La réponse envoyée au client ................................................................................................................................................................................. Retour sur notre application .................................................................................................................................................................................... Les composants de l'application ............................................................................................................................................................................. Le routeur ................................................................................................................................................................................................................ Réfléchissons, schématisons .................................................................................................................................................................................. Codons .................................................................................................................................................................................................................... Le back controller .................................................................................................................................................................................................... Réfléchissons, schématisons .................................................................................................................................................................................. Codons .................................................................................................................................................................................................................... Accéder aux managers depuis le contrôleur ........................................................................................................................................................... À propos des managers .......................................................................................................................................................................................... La page ................................................................................................................................................................................................................... Réfléchissons, schématisons .................................................................................................................................................................................. Codons .................................................................................................................................................................................................................... Retour sur la classe BackController ........................................................................................................................................................................ Retour sur la méthode HTTPResponse::redirect404() ............................................................................................................................................ Bonus : l'utilisateur .................................................................................................................................................................................................. Réfléchissons, schématisons .................................................................................................................................................................................. Codons .................................................................................................................................................................................................................... Bonus 2 : la configuration ........................................................................................................................................................................................ Réfléchissons, schématisons .................................................................................................................................................................................. Codons ....................................................................................................................................................................................................................

243 243 243 244 246 247 248 248 250 254 254 255 256 258 260 260 261 262 263 263 264 264 265 265 266

Le frontend .................................................................................................................................................................... 269 L'application ............................................................................................................................................................................................................ 269 La classe FrontendApplication ................................................................................................................................................................................ 269 Le layout .................................................................................................................................................................................................................. 269 Les deux fichiers de configuration ........................................................................................................................................................................... 271 L'instanciation de FrontendApplication .................................................................................................................................................................... 272 Réécrire toutes les URL .......................................................................................................................................................................................... 272 Le module de news ................................................................................................................................................................................................. 272 Fonctionnalités ........................................................................................................................................................................................................ 272 Structure de la table news ....................................................................................................................................................................................... 272 L'action index .......................................................................................................................................................................................................... 274 L'action show ........................................................................................................................................................................................................... 277 Ajoutons des commentaires .................................................................................................................................................................................... 280 Cahier des charges ................................................................................................................................................................................................. 280 Structure de la table comments .............................................................................................................................................................................. 280 L'action insertComment ........................................................................................................................................................................................... 281 Affichage des commentaires ................................................................................................................................................................................... 284

Le backend .................................................................................................................................................................... 287 L'application ............................................................................................................................................................................................................ 288 La classe BackendApplication ................................................................................................................................................................................ 288 Le layout .................................................................................................................................................................................................................. 289 Les deux fichiers de configuration ........................................................................................................................................................................... 289 L'instanciation de BackendApplication .................................................................................................................................................................... 289 Réécrire les URL ..................................................................................................................................................................................................... 290 Le module de connexion ......................................................................................................................................................................................... 290 La vue ...................................................................................................................................................................................................................... 290 Le contrôleur ........................................................................................................................................................................................................... 291 Le module de news ................................................................................................................................................................................................. 291 Fonctionnalités ........................................................................................................................................................................................................ 291 L'action index .......................................................................................................................................................................................................... 292 L'action insert .......................................................................................................................................................................................................... 293 L'action update ........................................................................................................................................................................................................ 297 L'action delete ......................................................................................................................................................................................................... 298 N'oublions pas les commentaires ! .......................................................................................................................................................................... 300 Fonctionnalités ........................................................................................................................................................................................................ 300 L'action updateComment ........................................................................................................................................................................................ 300 L'action deleteComment .......................................................................................................................................................................................... 304

Gérer les formulaires ..................................................................................................................................................... 306 Le formulaire ........................................................................................................................................................................................................... 307 Conception du formulaire ........................................................................................................................................................................................ 307 Développement de l'API .......................................................................................................................................................................................... 309 Testons nos nouvelles classes ................................................................................................................................................................................ 314 Les validateurs ........................................................................................................................................................................................................ 315 Conception des classes .......................................................................................................................................................................................... 315 Développement des classes ................................................................................................................................................................................... 316 Modification de la classe Field ................................................................................................................................................................................ 317 Le constructeur de formulaires ................................................................................................................................................................................ 320 Conception des classes .......................................................................................................................................................................................... 320 Développement des classes ................................................................................................................................................................................... 321 Modification des contrôleurs .................................................................................................................................................................................... 323 Le gestionnaire de formulaires ................................................................................................................................................................................ 325 Conception du gestionnaire de formulaire .............................................................................................................................................................. 326 Développement du gestionnaire de formulaire ....................................................................................................................................................... 326 Modification des contrôleurs .................................................................................................................................................................................... 327

Partie 4 : Annexes ........................................................................................................................... 328 L'opérateur instanceof ................................................................................................................................................... 328 Présentation de l'opérateur ..................................................................................................................................................................................... 328


Lire aussi

6/333

instanceof et l'héritage ............................................................................................................................................................................................ 330 instanceof et les interfaces ...................................................................................................................................................................................... 330 En résumé ............................................................................................................................................................................................................... 332


Lire aussi

7/333

Programmez en orienté objet en PHP

Par

Victor Thuillier (vyk12)

Mise à jour : 08/01/2013 Difficulté : Intermédiaire

Durée d'étude : 1 mois

1 visites depuis 7 jours, classé 30/807 Bienvenue dans ce tutoriel sur la programmation orientée objet (souvent abrégé par ses initiales « POO ») en PHP. Ici, vous allez découvrir un nouveau moyen de penser votre code, un nouveau moyen de le concevoir. Vous allez le représenter de façon orienté objet, un moyen de conception inventé dans les années 1970 et qui prend de plus en plus de place aujourd'hui. La principale raison de ce succès est due à de nombreux avantages apportés par ce paradigme, comme une organisation plus cohérente de vos projets, une maintenance plus facile et une distribution de votre code plus aisée. Cependant, avant de vous lancer dans ce (très) vaste domaine, vous devez avoir quelques connaissances au préalable.

Ce qui doit être acquis Afin de suivre au mieux ce tutoriel, il est indispensable voire obligatoire : d'être à l'aise avec PHP et sa syntaxe. Si ce n'est pas le cas, le Site du Zéro propose un tutoriel ; d'avoir bien pratiqué ; d'être patient ; d'avoir PHP 5 sur son serveur. Je ne parlerai pas de POO en PHP 4 car sous cette version de PHP, certaines fonctions indispensables de la POO ne sont pas présentes (on ne peut donc pas vraiment parler de POO). Si vous avez déjà pratiqué d'autres langages apportant la possibilité de programmer orienté objet, c'est un gros plus, surtout si vous savez programmer en Java (PHP a principalement tiré son modèle objet de ce langage).


Programmez en orienté objet en PHP

8/333

Partie 1 : [Théorie] Les bases de la POO

Introduction à la POO Alors ça y est, vous avez décidé de vous lancer dans la POO en PHP ? Sage décision ! Nous allons donc plonger dans ce vaste domaine par une introduction à cette nouvelle façon de penser : qu'est-ce que la POO ? En quoi ça consiste ? En quoi est-ce si différent de la méthode que vous employez pour développer votre site web ? Tant de questions auxquelles je vais répondre. Cependant, puisque je sais que vous avez hâte de commencer, nous allons entamer sérieusement les choses en créant notre première classe dès la fin de ce chapitre. Vous commencerez ainsi vos premiers pas dans la POO en PHP !

Qu'est-ce que la POO ? Il était une fois le procédural Commençons ce cours en vous posant une question : comment est représenté votre code ? La réponse est unique : vous avez utilisé la « représentation procédurale » qui consiste à séparer le traitement des données des données elles-mêmes. Par exemple, vous avez un système de news sur votre site. D'un côté, vous avez les données (les news, une liste d'erreurs, une connexion à la BDD, etc.) et de l'autre côté vous avez une suite d'instructions qui viennent modifier ces données. Si je ne me trompe pas, c'est de cette manière que vous codez. Cette façon de se représenter votre application vous semble sans doute la meilleure puisque c'est la seule que vous connaissez. D'ailleurs, vous ne voyez pas trop comment votre code pourrait être représenté de manière différente. Eh bien cette époque d'ignorance est révolue : voici maintenant la programmation orientée objet !

Puis naquit la programmation orientée objet Alors, qu'est-ce donc que cette façon de représenter son code ? La POO, c'est tout simplement faire de son site un ensemble d'objets qui interagissent entre eux. En d'autres termes : tout est objet.

Définition d'un objet Je suis sûr que vous savez ce que c'est. D'ailleurs, vous en avez pas mal à côté de vous : je suis sûr que vous avez un ordinateur, une lampe, une chaise, un bureau, ou que sais-je encore. Ce sont tous des objets. En programmation, les objets sont sensiblement la même chose. L'exemple le plus pertinent quand on fait un cours sur la POO est d'utiliser l'exemple du personnage dans un jeu de combat. Ainsi, imaginons que nous ayons un objet Personnage dans notre application. Un personnage a des caractéristiques : une force ; une localisation ; une certaine expérience ; et enfin des dégâts. Toutes ses caractéristiques correspondent à des valeurs. Comme vous le savez sûrement, les valeurs sont stockées dans des variables. C'est toujours le cas en POO. Ce sont des variables un peu spéciales, mais nous y reviendrons plus tard. Mis à part ces caractéristiques, un personnage a aussi des capacités. Il peut : frapper un autre personnage ; gagner de l'expérience ; se déplacer. Ces capacités correspondent à des fonctions. Comme pour les variables, ce sont des fonctions un peu spéciales et on y reviendra en temps voulu. En tout cas, le principe est là. Vous savez désormais qu'on peut avoir des objets dans une application. Mais d'où sortent-ils ? Dans la vie réelle, un objet ne sort pas de nulle part. En effet, chaque objet est défini selon des caractéristiques et un plan bien précis. En POO, ces informations sont contenues dans ce qu'on appelle des classes.



9/333

Définition d'une classe Comme je viens de le dire, les classes contiennent la définition des objets que l'on va créer par la suite. Prenons l'exemple le plus simple du monde : les gâteaux et leur moule. Le moule est unique. Il peut produire une quantité infinie de gâteaux. Dans ce cas-là, les gâteaux sont les objets et le moule est la classe : le moule va définir la forme du gâteau. La classe contient donc le plan de fabrication d'un objet et on peut s'en servir autant qu'on veut afin d'obtenir une infinité d'objets. Concrètement, une classe, c'est quoi ?

Une classe est une entité regroupant des variables et des fonctions. Chacune de ces fonctions aura accès aux variables de cette entité. Dans le cas du personnage, nous aurons une fonction frapper(). Cette fonction devra simplement modifier la variable $degats du personnage en fonction de la variable $force. Une classe est donc un regroupement logique de variables et fonctions que tout objet issu de cette classe possédera.

Définition d'une instance Une instance, c'est tout simplement le résultat d'une instanciation. Une instanciation, c'est le fait d'instancier une classe. Instancier une classe, c'est se servir d'une classe afin qu'elle nous crée un objet. En gros, une instance est un objet.

Exemple : création d'une classe Nous allons créer une classe Personnage (sous forme de schéma bien entendu). Celle-ci doit contenir la liste des variables et des fonctions que l'on a citées plus haut : c'est la base de tout objet Personnage. Chaque instance de cette classe possédera ainsi toutes ces variables et fonctions. Voici donc cette fameuse classe à la figure suivante.

Le schéma de notre classe

Vous voyez donc les variables et fonctions stockées dans la classe Personnage. Sachez qu'en réalité, on ne les appelle pas comme ça : il s'agit d'attributs (ou propriétés) et de méthodes. Un attribut désigne une variable et une méthode désigne une fonction. Ainsi, tout objet Personnage aura ces attributs et méthodes. On pourra modifier ces attributs et invoquer ces méthodes sur notre objet afin de modifier ses caractéristiques ou son comportement.

Le principe d'encapsulation www.openclassrooms.com


10/333

L'un des gros avantages de la POO est que l'on peut masquer le code à l'utilisateur (l'utilisateur est ici celui qui se servira de la classe, pas celui qui chargera la page depuis son navigateur). Le concepteur de la classe a englobé dans celle-ci un code qui peut être assez complexe et il est donc inutile voire dangereux de laisser l'utilisateur manipuler ces objets sans aucune restriction. Ainsi, il est important d'interdire à l'utilisateur de modifier directement les attributs d'un objet. Prenons l'exemple d'un avion où sont disponibles des centaines de boutons. Chacun de ces boutons constituent des actions que l'on peut effectuer sur l'avion. C'est l'interface de l'avion. Le pilote se moque de quoi est composé l'avion : son rôle est de le piloter. Pour cela, il va se servir des boutons afin de manipuler les composants de l'avion. Le pilote ne doit pas se charger de modifier manuellement ces composants : il pourrait faire de grosses bêtises. Le principe est exactement le même pour la POO : l'utilisateur de la classe doit se contenter d'invoquer les méthodes en ignorant les attributs. Comme le pilote de l'avion, il n'a pas à les trifouiller. Pour instaurer une telle contrainte, on dit que les attributs sont privés. Pour l'instant, ceci peut sans doute vous paraître abstrait, mais nous y reviendrons. Bon, je pense que j'ai assez parlé, commençons par créer notre première classe !

Créer une classe Syntaxe de base Le but de cette section va être de traduire la figure précédente en code PHP. Avant cela, je vais vous donner la syntaxe de base de toute classe en PHP : Code : PHP

Cette syntaxe est à retenir absolument. Heureusement, elle est simple. Ce qu'on vient de faire est donc de créer le moule, le plan qui définira nos objets. On verra dans le prochain chapitre comment utiliser ce plan afin de créer un objet. Pour l'instant, contentons-nous de construire ce plan et de lui ajouter des fonctionnalités. La déclaration d'attributs dans une classe se fait en écrivant le nom de l'attribut à créer, précédé de sa visibilité.

Visibilité d'un attribut ou d'une méthode La visibilité d'un attribut ou d'une méthode indique à partir d'où on peut y avoir accès. Nous allons voir ici deux types de visibilité : public et private. Le premier, public, est le plus simple. Si un attribut ou une méthode est public, alors on pourra y avoir accès depuis n'importe où, depuis l'intérieur de l'objet (dans les méthodes qu'on a créées), comme depuis l'extérieur. Je m'explique. Quand on crée un objet, c'est principalement pour pouvoir exploiter ses attributs et méthodes. L'extérieur de l'objet, c'est tout le code qui n'est pas dans votre classe. En effet, quand vous créerez un objet, cet objet sera représenté par une variable, et c'est à partir d'elle qu'on pourra modifier l'objet, appeler des méthodes, etc. Vous allez donc dire à PHP « dans cet objet, donne-moi cet attribut » ou « dans cet objet, appelle cette méthode » : c'est ça, appeler des attributs ou méthodes depuis l'extérieur de l'objet. Le second, private, impose quelques restrictions. On n'aura accès aux attributs et méthodes seulement depuis l'intérieur de la classe, c'est-à-dire que seul le code voulant accéder à un attribut privé ou une méthode privée écrit(e) à l'intérieur de la classe fonctionnera. Sinon, une jolie erreur fatale s'affichera disant que vous ne pouvez pas accéder à telle méthode ou tel attribut parce qu'il ou elle est privé(e). Là, ça devrait faire tilt dans votre tête : le principe d'encapsulation ! C'est de cette manière qu'on peut interdire l'accès à nos attributs.

Création d'attributs www.openclassrooms.com


11/333

Pour déclarer des attributs, on va donc les écrire entre les accolades, les uns à la suite des autres, en faisant précéder leurs noms du mot-clé private, comme ça : Code : PHP

// // // //

La force du personnage Sa localisation Son expérience Ses dégâts

Vous pouvez constater que chaque attribut est précédé d'un underscore (« _ »). Ceci est une notation qu'il est préférable de respecter (il s'agit de la notation PEAR) qui dit que chaque nom d'élément privé (ici il s'agit d'attributs, mais nous verrons plus tard qu'il peut aussi s'agir de méthodes) doit être précédé d'un underscore. Vous pouvez initialiser les attributs lorsque vous les déclarez (par exemple, leur mettre une valeur de 0 ou autre). Exemple : Code : PHP

// La force du personnage, par // Sa localisation, par défaut à // Son expérience, par défaut à // Ses dégâts, par défaut à 0.

La valeur que vous leur donnez par défaut doit être une expression constante. Par conséquent, leur valeur ne peut être issue d'un appel à une fonction (private $_attribut = intval('azerty')), d'une opération (private $_attribut = 1 + 1), d'une concaténation (private $_attribut = 'Mon ' . 'super ' . 'attribut') ou d'une variable, superglobale ou non (private $_attribut = $_SERVER['REQUEST_URI']).

Création de méthodes Pour la déclaration de méthodes, il suffit de faire précéder le mot-clé function à la visibilité de la méthode. Les types de visibilité des méthodes sont les mêmes que les attributs. Les méthodes n'ont en général pas besoin d'être masquées à l'utilisateur, vous les mettrez souvent en public (à moins que vous teniez absolument à ce que l'utilisateur ne puisse pas appeler cette méthode, par exemple s'il s'agit d'une fonction qui simplifie certaines tâches sur l'objet mais qui ne doit pas être appelée n'importe comment). Code : PHP

Essayons maintenant de créer un objet pour voir si il sera chargé automatiquement (je prends pour exemple la classe Personnage et prends en compte le fait qu'un fichier Personnage.class.php existe). Code : PHP

Et là, comme par magie, aucune erreur ne s'affiche ! Notre auto-chargement a donc bien fonctionné. Décortiquons ce qui s'est passé. En PHP, il y a ce qu'on appelle une « pile d'autoloads ». Cette pile contient une liste de fonctions. Chacune d'entre elles sera appelée automatiquement par PHP lorsque l'on essaye d'instancier une classe non déclarée.



26/333

Nous avons donc ici ajouté notre fonction à la pile d'autoloads afin qu'elle soit appelée à chaque fois qu'on essaye d'instancier une classe non déclarée. Schématiquement, la figure suivante montre ce qui s'est passé.

L'autoload en PHP

Sachez que vous pouvez enregistrer autant de fonctions en autoload que vous le voulez avec spl_autoload_register. Si vous en enregistrez plusieurs, elles seront appelées dans l'ordre de leur enregistrement jusqu'à ce que la classe soit chargée. Pour y parvenir, il suffit d'appeler spl_autoload_register pour chaque fonction à enregistrer. Voici un chapitre aussi essentiel que le premier et toujours aussi riche en nouveautés fondant les bases de la POO. Prenez bien le temps de lire et relire ce chapitre si vous êtes un peu perdus, sinon vous ne pourrez jamais suivre !

En résumé Un objet se crée grâce à l'opérateur new. L'accès à un attribut ou à une méthode d'un objet se fait grâce à l'opérateur « -> ». Pour lire ou modifier un attribut, on utilise des accesseurs et des mutateurs. Le constructeur d'une classe a pour rôle principal d'initialiser l'objet en cours de création, c'est-à-dire d'initialiser la valeur des attributs (soit en assignant directement des valeurs spécifiques, soit en appelant diverses méthodes). Les classes peuvent être chargées dynamiquement (c'est-à-dire sans avoir explicitement inclus le fichier la déclarant) grâce à l'auto-chargement de classe (utilisation de spl_autoload_register).



27/333

L'opérateur de résolution de portée L'opérateur de résolution de portée (« :: »), appelé « double deux points » (« Scope Resolution Operator » en anglais), est utilisé pour appeler des éléments appartenant à telle classe et non à tel objet. En effet, nous pouvons définir des attributs et méthodes appartenant à la classe : ce sont des éléments statiques. Nous y reviendrons en temps voulu dans une partie dédiée à ce sujet. Parmi les éléments appartenant à la classe (et donc appelés via cet opérateur), il y a aussi les constantes de classe, sortes d'attributs dont la valeur est constante, c'est-à-dire qu'elle ne change pas. Nous allons d'ailleurs commencer par ces constantes de classe. Cet opérateur est aussi appelé « Paamayim Nekudotayim ». Mais rassurez-vous, je ne vais pas vous demander de le retenir (si vous y arrivez, bien joué ).

Les constantes de classe Commençons par les constantes de classe. Le principe est à peu près le même que lorsque vous créez une constante à l'aide de la fonction define. Les constantes de classe permettent d'éviter tout code muet. Voici un code muet : Code : PHP

Pourquoi est-il muet ? Tout simplement parce qu'on ne sait pas à quoi « 50 » correspond. Qu'est-ce que cela veut dire ? Étant donné que je viens de réaliser le script, je sais que ce « 50 » correspond à la force du personnage. Cependant, ce paramètre ne peut prendre que 3 valeurs possibles : 20, qui veut dire que le personnage aura une faible force ; 50, qui veut dire que le personnage aura une force moyenne ; 80, qui veut dire que le personnage sera très fort. Au lieu de passer ces valeurs telles quelles, on va plutôt passer une constante au constructeur. Ainsi, quand on lira le code, on devinera facilement que l'on passe une force moyenne au constructeur. C'est bien plus facile à comprendre qu'un nombre quelconque. Une constante est une sorte d'attribut appartenant à la classe dont la valeur ne change jamais. Ceci est peut-être un peu flou, c'est pourquoi nous allons passer à la pratique. Pour déclarer une constante, vous devez faire précéder son nom du mot-clé const. Faites bien attention, une constante ne prend pas de « $ » devant son nom ! Voici donc comment créer une constante : Code : PHP

}

Et voilà ! Facile n'est-ce pas ? Bien sûr, vous pouvez assigner à ces constantes d'autres valeurs. Et quel est le rapport avec tes « double deux points » ?

Contrairement aux attributs, vous ne pouvez accéder à ces valeurs via l'opérateur « -> » depuis un objet (ni $this ni $perso ne fonctionneront) mais avec l'opérateur « :: » car une constante appartient à la classe et non à un quelconque objet. Pour accéder à une constante, vous devez spécifier le nom de la classe, suivi du symbole double deux points, suivi du nom de la constante. Ainsi, on pourrait imaginer un code comme celui-ci : Code : PHP

Et lors de la création de notre personnage : Code : PHP

Notez qu'ici les noms de constantes sont en majuscules : c'est encore et toujours une convention de dénomination.

Reconnaissez que ce code est plus lisible que celui montré au début de cette sous-partie.

Les attributs et méthodes statiques Les méthodes statiques Comme je l'ai brièvement dit dans l'introduction, les méthodes statiques sont des méthodes qui sont faites pour agir sur une classe et non sur un objet. Par conséquent, je ne veux voir aucun $this dans la méthode ! En effet, la méthode n'étant appelée sur aucun objet, il serait illogique que cette variable existe. Souvenez-vous : $this est un paramètre implicite. Cela n'est vrai que pour les méthodes appelées sur un objet ! Même si la méthode est dite « statique », il est possible de l'appeler depuis un objet ($obj>methodeStatique()), mais, même dans ce contexte, la variable $this ne sera toujours pas passée !

Pour déclarer une méthode statique, vous devez faire précéder le mot-clé function du mot-clé static après le type de visibilité. Code : PHP " />
Titre Contenu , le

Modifiée le Posté par le

Ce code se passe de commentaires, les valeurs affichées détaillant assez bien je pense. Après avoir vu l'utilisation de l'opérateur avec les interfaces, nous allons voir comment il réagit lorsqu'on lui passe en paramètre une interface qui est héritée par une autre interface qui est implémentée par une classe qui est instanciée. Vous voyez à peu près à quoi je fais sréférence ? Je vais procéder en PHP au cas où vous n'ayez pas tout suivi. Code : PHP

Vous savez maintenant tous les comportements que peut adopter cet opérateur et tous les effets qu'il peut produire (tout est écrit dans le précédent code).

En résumé L'opérateur instanceof permet de vérifier la nature de la classe dont l'objet testé est une instance. Cet opérateur permet de vérifier qu'un certain objet est bien une instance d'une classe fille de telle classe. Cet opérateur permet de vérifier qu'un certain objet est une instance d'une classe implémentant telle interface, ou que l'une de ses classes mère l'implémente. Ce tutoriel est maintenant terminé. J'espère qu'il vous aura plu et apporté beaucoup de connaissances.

Pour aller plus loin Dès à présent, vous êtes prêts à être lâchés dans la nature. Cependant, il est possible d'aller encore plus loin dans le monde de l'orienté objet. En effet, la meilleure technique pour progresser est de pratiquer afin d'être le plus à l'aise possible avec ce paradigme. Cette pratique s'acquiert en utilisant des frameworks orientés objets. Il en existe un bon nombre, dont voici les principaux. Symfony. Framework assez complet et puissant, il est beaucoup utilisé dans le monde professionnel (le Site du Zéro l'utilise par exemple). Si ce framework vous intéresse, je vous conseille de lire le tutoriel sur Symfony disponible sur ce site. Si vous avez lu et compris la partie « Réalisation d'un site web », l'apprentissage des bases de ce framework sera quasi instantanée (cette partie du tutoriel s'inspire beaucoup de Symfony). Zend Framework. Framework encore plus complet, souvent comparé à une usine à gaz. Certains diront que c'est une qualité (car le framework est par conséquent très souple et s'adapte à votre façon de coder), d'autres un défaut. Ce framework est aussi très utilisé dans le milieu professionnel. CodeIgniter. Framework bien plus léger mais moins complet. C'est à vous de compléter sa bibliothèque, soit en téléchargeant des scripts que la communauté a développés, soit en les créant vous-mêmes. Lire le tutoriel sur CodeIgniter disponible sur ce site. CakePHP. Ce framework a cherché du même côté que Symfony pour trouver son inspiration. Par conséquent, là aussi, l'apprentissage des bases de ce framework sera très rapide. Si vous voulez vous pencher sur CakePHP, je vous conseille le CakePHP Cookbook.

Merci à Talus et Lpu8er concernant l'UML, à christophetd pour la correction orthographique de quelques chapitres, à prs513rosewood pour l'installation de Dia sous Mac OS, et à tous les autres qui commentent pour m'aider ou m'encourager !


Programmez en orienté objet en PHP - Site du Zéro

Programmez en orienté objet en PHP - Site du Zéro

Suggest Documents

Les Templates en PHP

Programmez avec le langage C++ - Site du Zéro

Apprendre à dessiner en 3D avec AutoCAD - Site du Zéro

La programmation système en C sous Unix - Site du Zéro

Règle du jeu (en PDF)

découverte du monde en maternelle

Guide du résident en gériatrie

Mise en oeuvre du GRAFCET

LA FILIÈRE DU MEUBLE EN FRANCE EN 1978

PREVISION DU BESOIN EN FONDS DE ROULEMENT - IUT en Ligne

Proposition de progression en Découverte du monde en PS-MS

EN 1 ANNEE DU CYCLE LICENCE EN SCIENCES ET TECHNIQUES ...

Programmation Orientée Objet - Les Universités à Aix en Provence

Quintessence Journals - Site en construction

Formation PHP Avancé : Programmation Orientée Objet ... - Dawan

La programmation orientée objet - 4e édition : Cours et exercices en ...

Programmer en PHP - Julien Gaulmin - Free

Zend Framework : Bien développer en PHP

etude du comportement en traction et en compression du beton de ...

Om du har en anekdot från en källa, ignorerar du ... - Pricken över Livet

Expérience du Tchad en matière de mise en œuvre du mécanisme ...

L'Histoire du Monde en 80 secrets - Numilog

Telecharger - guide du debutant en aeromodelisme

Consulter un extrait du cahier en pdf