PHP5 – POO

Année universitaire : 2014 / 2015

 Plan
• Introduction à la POO et terminologie
• Classes, propriétés, méthodes et constantes
• Encapsulation et visibilité
• Constructeur, destructeur, instanciation d'objets
• Héritage, polymorphisme, classe abstraite et interface
• Les namespaces
• Fonctions magiques
 Définition

La programmation orientée objet (POO) consiste à modéliser

informatiquement un ensemble d'éléments d'une partie du monde réel en
un ensemble d'entités informatiques.

Ces entités informatiques sont appelées objets. Il s'agit de données

informatiques regroupant les caractéristiques et le comportement des
éléments du monde réel
 Définition
On appelle classe la structure d'un objet, c'est-à-dire la déclaration de
l'ensemble des entités (attributs et méthodes) qui composeront un objet.
Une classe est composée de deux parties :

● Les attributs : Les données représentant l'état de l'objet.

● Les méthodes : Les opérations du comportement de l’objet.
 Définition
Un objet est une instanciation d'une classe permettant d'encapsuler du code
et des données.
Si on définit une classe Voiture par exemple, les objets Peugeot, Renault
seront des instanciations (des objets) de cette classe.
Définition
 Les attributs
• À l'intérieur des accolades d’une classe, nous allons définir
des attributs
• Les variables permettent de définir les caractéristiques de
l'objet

• Attributs = Propriétés = Variables d’instance = Etat

 Les méthodes
• Les méthodes sont des opérations que la classe peut exécuté, il
permettent soit de lire ou mettre à jour les variables (getters et setters) ou
d’exécuter des actions plus complexes sur la classe

• Le mot-clé « $this » signifie

• l’instance courante de l’objet

• Méthodes = Opérations
= Fonctions = Comportement
 Les constantes de classe
Une constante est une sorte d'attribut appartenant à la classe dont la valeur ne change jamais.
Pour déclarer une constante, on doit précéder son nom du mot-clé « const ».

Pour accéder à une constante, on doit spécifier le nom de la classe, suivi du symbole double deux
points, suivi du nom de la constante.
 Remarque
• Les deux mots-clés « const » et « define() » servent à
définir des constantes, quelle est donc la différence
entre les deux ?

• « const » sert à définir une constante de classe

• « define() » définit une constante dans le contexte
global
 Remarque
• Le code d'une classe étant en général assez long, il est recommandé de créer un
fichier PHP qui contiendra uniquement la définition de la classe et que l'on inclura
à chaque fois qu'on en a besoin.

Par convention :
• On donne l'extension .class.php aux fichiers des classes
• On définit une classe par fichier, et qui porte le même nom que sa classe
• Le nom de la classe commence par une majuscule et s’ecrit en Camel Case
• Les attributs et méthodes s’écrivent en Camel Case et commence par une
minuscule (ex: nomFamille, afficherNomFamille(), …)
• Les constantes s’écrivent tout en majuscule avec des underscore pour séparer les
mots (ex: AGE_MIN_REQUIS).
 Les attributs statiques
• Un attribut statique est un attribut qui appartient à la classe elle-même et non pas son
instance (objet). C’est un attribut partagé entre toutes les instances de la classe.
La déclaration d'un attribut statique se fait en précédant son nom par « static » :

On peut créer plusieurs objets de la classe Voiture, l’attribut static aura toujours la même valeur,
sauf si l'objet lui même modifie sa valeur. Si c’est le cas, tous les autres objets qui accéderont
à cet attribut obtiendront la nouvelle valeur.
 Les attributs statiques
• On n'accède pas à un attribut statique avec « $this » mais avec « self » !
• « self » représente la classe tandis que « $this » représente l'objet créé (l’instance courante).
 Les méthodes statiques
Tout comme les attributs statiques, les méthodes statiques sont faites pour agir au niveau de la
classe elle-même et non pas sur son instance (objet).
Pour déclarer une méthode statique, on doit précéder le mot-clé function par « static »

Et pour l'appeler, on doit procéder comme suit :

 L’encapsulation
L'encapsulation est un mécanisme qui permet de garantir l'intégrité des
données contenues dans l'objet, en interdisant à l'utilisateur de modifier
directement les attributs, et en l'obligeant à utiliser les fonctions définies
pour les modifier.

• L'encapsulation permet de définir des niveaux de visibilité des éléments

de la classe. Ces niveaux de visibilité définissent les droits d'accès aux
données.
 L’encapsulation
Il existe quatre niveaux de visibilité:

● Publique : les fonctions de toutes les classes peuvent accéder aux données ou aux méthodes
d'une classe définie avec le niveau de visibilité public. Il s'agit du plus bas niveau de protection
des données.
● Privée : l'accès aux données est limité aux méthodes de la classe elle-même. Il s'agit du niveau
de protection des données le plus élevé.
● Protégée : l'accès aux données est réservé aux fonctions des classes héritières, c'est-à-dire par
les fonctions membres de la classe ainsi que des classes dérivées.
● Friendly : c’est comme publique mais juste pour les classes du même package, ce niveau n’a pas
de mot-clé c’est celui adopté par défaut si on ne spécifie rien
L’encapsulation
 Le constructeur
• Le rôle d'une fonction constructeur est de construire l'objet : c'est-à-dire de le préparer à une
première utilisation.
 Le constructeur
On a deux types de constructeurs :
• Constructeur par défaut : Constructeur sans arguments qui initialise les
attributs à la valeur NULL.
• Constructeur avec arguments : Constructeur permettant d’initialiser les
attributs aux valeurs passées en paramètre.

• Si on crée aucun constructeur dans la classe, un constructeur par défaut

est fourni automatiquement par PHP.

• Si on définit un constructeur avec arguments, on doit nous même fournir

un constructeur par défaut si on veut instancier la classe sans arguments.
 Le destructeur
• Le rôle du destructeur est de réaliser toutes les opérations nécessaires pour mettre fin à la
vie de l'objet.
• Le destructeur est appelée automatiquement par PHP lorsque l'objet est détruit.
• La classe PDO, par exemple, a besoin d'utiliser le destructeur pour fermer la connexion à la
base de données.
 Instanciation d'objets
• Pour créer un nouvel objet, on doit précéder le nom de la classe à instancier du mot-clé new,
comme ceci :
 Héritage
• L'héritage est un principe propre à la programmation orientée objet,
permettant de créer une nouvelle classe en se basant sur une classe
existante.

• L'intérêt majeur de l'héritage est de pouvoir définir de nouveaux attributs

et méthodes pour la classe dérivée en plus de ceux héritées.

• Par ce moyen on crée une hiérarchie de classes de plus en plus

spécialisées. Cela a comme avantage majeur de ne pas avoir à repartir de
zéro lorsque l'on veut spécialiser une classe existante.
Héritage
 Héritage
• Pour procéder à un héritage, il suffit d'utiliser le mot-clé
« extends » comme ceci :

• Il faut aussi penser à inclure le fichier PHP de la classe mère !

 Héritage
• Pour appeler un attribut ou une fonction de la
classe mère, on utilise le mot-clé « parent »
 Classe final
• Une classe final ne peut pas être dérivée, On ne peut
pas créer de classe fille héritant de cette classe.

• Pour déclarer une classe finale, on doit placer le mot-

clé « final » juste avant « class » comme suit :
 Méthode final
• Si on déclare une méthode « final », toute classe
fille peut l’utiliser mais ne pourra plus la
surcharger.
• Une méthode ne peut être « abstract » et « final »
à la fois !
 Polymorphisme
• Le nom « polymorphisme » signifie « peut prendre
plusieurs formes ».

• Cette caractéristique est une des concepts essentiels

de la programmation orientée objet. Alors que
l'héritage concerne les classes, le polymorphisme est
relatif aux méthodes des objets.
 Polymorphisme
• On distingue généralement trois types de
polymorphisme :
 Le polymorphisme ad hoc
• Le polymorphisme ad hoc, représente la
possibilité de définir plusieurs fonctions
de même nom mais possédant des
paramètres différents en nombre.
 Le polymorphisme ad hoc
• On peut par exemple définir plusieurs méthodes homonymes
addition() effectuant une somme de valeurs.

• La méthode afficher(string)
• La méthode afficher(string, string)
• La méthode afficher(string, string, string)

• Chaque méthode est une surcharge (en nombre) de l’autre.

 Le polymorphisme paramétrique
• Le polymorphisme paramétrique, représente la
possibilité de définir plusieurs fonctions de même
nom mais possédant des paramètres différents en
type.
• Le polymorphisme paramétrique rend ainsi le choix
automatique de la bonne méthode à adopter en
fonction du type de donnée passée en paramètre.
 Le polymorphisme paramétrique
• On peut par exemple définir plusieurs méthodes homonymes addition()
effectuant une somme de valeurs.

• La méthode addition(int, int) pourra retourner la somme de deux entiers.

• La méthode addition(float, float) pourra retourner la somme de deux
flottants.
• La méthode addition(char, char) pourra définir au gré de l'auteur la
somme de deux caractères.

• Chaque méthode est une surcharge (en type) de l’autre.

 Le polymorphisme d'héritage
• La possibilité de redéfinir une méthode dans
des classes héritant d'une classe de base
• s'appelle la spécialisation. Il est alors possible
d'appeler la méthode d'un objet sans se
soucier de son type intrinsèque.
 Le polymorphisme d'héritage
• Imaginons un jeu d'échec comportant des objets
• roi, reine, fou, cavalier, tour et pion, héritant chacun de l'objet
piece.
• La méthode mouvement() pourra, grâce au polymorphisme
• d'héritage, effectuer le mouvement approprié en fonction de
la classe de l'objet référencé au moment de l'appel. Cela
permettra notamment au programme de dire
piece.mouvement() sans avoir à se préoccuper de la classe de
la pièce.
 Classe abstraite
• Une classe abstraite est une classe non
instanciable, permettant de factoriser un
ensemble de propriétés et de méthodes
communes, voire même un constructeur
commun.
 Classe abstraite
• Pour déclarer une classe abstraite, il suffit de faire précéder le
mot-clé « class » par « abstract » comme ceci :

• Sans oublier d’inclure le fichier PHP de la classe mère

 Classe abstraite
• Une méthode abstraite est signalée par le
modificateur abstract placé au début de son
en-tête. Une telle méthode n'a alors que son
prototype.

• Une méthode abstraite ne peut pas être

déclarée static ou private ou final.
 Classe abstraite
• Pour rendre une méthode abstraite, on place le mot-clé
"abstract" juste avant la visibilité de la méthode comme ceci :
 Interface
• Une interface est un artefact qui ne contient que des
méthodes abstraites et n'implémente aucun attribut ni
méthode (hormis des constantes).

• Elle sert de contrat pour ses classes filles

• Toutes les méthodes présentes dans une interface doivent

être publiques.

• Une interface ne peut pas lister de méthodes finales.

 Interface
• Une interface se déclare avec le mot-clé « interface », suivi du
nom de l'interface.
• Pour implémenter l'interface IVidangable à la classe Voiture, il
suffit d'utiliser le mot-clé « implements » comme ceci :

• N’oubliez pas d’inclure le fichier PHP de l’interface mère

 Remarque
Problématique :
• Quand utiliser une interface et quand utiliser une classe abstraite ?

Réponse :
• On utilise une classe abstraite s’il y’a un comportement (implémentation
de fonction) par défaut commune entre les classes filles

• On utilise une interface si les classes filles qui l’implémentent n’ont pas
besoin d’exhiber un comportement par défaut.
 Les namespaces
Problématique :
• Comment créer deux constantes, deux
fonctions ou deux classes portant le même
nom ?

Solution :
• L'idée est la même que l'organisation des
fichiers.
 Les namespaces
• Pour déclarer un namespace, il faut utiliser le
mot-clé namespace suivi du nom de l’espace
de nom à créer :
 Les namespaces
• On va créer une fonction ayant le même nom
qu'une autre fournie par PHP :
 Les namespaces
• Si on veut appeler une fonction du namespace
global : on doit précéder le nom de la fonction
d'un backslash (\), comme ceci :
 Les namespaces
• Pour créer un namespace à l'intérieur d'un
autre, on écrira l'arborescence du namespace.
Ainsi, si on veut créer un namespace B dans A,
on fera comme ça :
 Les namespaces
• Pour pouvoir appeler des constantes, fonctions ou classes d'un
namespace différent, il suffit de spécifier le namespace auquel
appartient l'élément juste avant de l'appeler. Comme pour les
fichiers, il y a deux façons de procéder :

• De façon relative : l'appel de l'élément dépendra du namespace

dans lequel vous êtes. Celui-ci est relatif au namespace courant.
• De façon absolue : l'appel de l'élément se fait en partant du
namespace global puis en listant tous les sous-namespaces jusqu'au
namespace souhaité.
Les namespaces
 Fonctions magiques
• Les fonctions magiques sont des méthodes avec des
noms spéciaux, commençant avec deux underscore
« __ » et dénotent les méthodes qui sont
déclenchées en réponse à un événement PHP
particulier.

• __construct et __destruct qu’on a vu lors des

chapitres précédents sont des fonctions magiques.
 Fonctions magiques
• __construct() • __sleep()
• __destruct() • __wakeup()
• __call() • __toString()
• __callStatic() • __invoke()
• __get() • __set_state()
• __set() • __clone()
• __isset() • __debugInfo()
• __unset()
 Fonctions magiques
• La méthode __set est appelée lorsque l'on essaye d'assigner une valeur à
un attribut auquel on n'a pas accès ou qui n'existe pas.

• Cette méthode prend deux paramètres : le premier est le nom de l'attribut

auquel on a tenté d'assigner une valeur, le second paramètre est la valeur
que l'on a tenté d'assigner à l'attribut.

• __get fait l’inverse, elle est appelée lorsqu’on essaye de retrouver une
valeur, et prend comme argument le nom de l’attribut qu’on a tenté
d’appeler.
Fonctions magiques
 Fonctions magiques
• La méthode __call est appelée lorsque l'on essaye d'appeler
une méthode qu'on n'y a pas accès (soit elle n'existe pas, soit
elle est privée).

• Elle prend deux arguments : le premier est le nom de la

méthode que l'on a essayé d'appeler et le second est la liste
des arguments qui lui ont été passés (sous forme de tableau).
Fonctions magiques
 Fonctions magiques
• La méthode __isset est appelée lorsque l'on appelle la
fonction isset sur un attribut qui n'existe pas ou auquel on n'a
pas accès.

• Étant donné que la fonction initiale isset renvoie true ou

false, la méthode magique __isset doit renvoyer un booléen.
Cette méthode prend un paramètre : le nom de l'attribut que
l'on a envoyé à la fonction isset.