International

Secteur. 25, avenue du Koucitenga

01 BP 6803 Ouagadougou 01, Burkina Faso

T el • (+ 226) 70 60 62 97 / (+ 226) 226 78 80 90"

Email• contac\Gyessitechgi:oup.com
Site web •www.essitechgi:oup.com
Fa c ebook ,vww.facebook com / essitech

Catalyser votre talent, accelerer votre reussite .

 Avril 2022

Cour de PHP
Programmation Orientée Objet

TOE Marcel Jocelyn

< Développeur web – Datascientist />
Agenda
01

02

03

04
#1 POO
 Qu’est ce que POO ?

“ La programmation orientée objet se base sur la manipulation d'entités

appelées objets.
Les objets sont plus concrets et plus perceptibles par les humains. Ils peuvent
représenter des entités physiques du quotidien comme une personne, une
maison, un arbre... “
 Pourquoi la Poo ?

Plus intuitif Plus organisé Plus évolutif

manipuler des objets Objet indépendantes Code organisé et plus
qui peuvent interagir les unes des autres facile a maintenir
entre eux

Code réutilisable Favorise le travail en équipe

le code peut être divisé en modules en découpant les parties du projet qui
plus faciles à réutiliser sont faciles à regrouper après
# Programmation orientée objet en PHP
 POO en PHP
• La programmation orientée objet (POO), ou programmation par objet, est
un paradigme de programmation informatique.

• Elle consiste en la définition et l'interaction de briques logicielles appelées

objets ;

• un objet représente un concept, une idée ou toute entité du monde

physique, comme une voiture, une personne ou encore une page d'un livre.

• Il possède une structure interne et un comportement, et il sait interagir

avec ses pairs.
# Notions de classe, objet et instanciation
 Qu'est ce qu'un objet?
• La programmation orientée objet est plus naturelle donc plus intuitive.
c'est parce qu’elle utilise des entités appelées objets.

• Un objet possède sa propre structure interne qui définit ses propriétés et

son comportement.

Si on compare avec le monde réel, les objets sont partout autour de nous.

L'objet "voiture" a des caractéristiques (ou propriétés) tel que: couleur, puissance du
Moteur, vitesse, source d'énergie. En POO, on les appelle des attributs.

L’objet voiture a également des comportements: accélérer, ralentir, etc…

En POO on les appelles des méthodes.
 Qu'est ce qu’une classe?
• C'est la classe qui se charge de donner vie aux objets.

• Une classe est une structure cohérente de propriétés (attributs) et de

comportements (méthodes).

• C'est elle qui contient la définition des objets qui vont être créés après.

• La création d’un classe se fait grâce au mot-clé class suivi du nom de la

classe.

La convention veut la 1ere lettre du nom commence par une lettre majuscule
 Instancer une classe
• La classe est le moule qui sert à fabriquer les objets.

• Le nombre d'objets que l'on peut créer à l'aide d'une classe est illimité.

• On appelle l'opération qui consiste à créer un objet instanciation et l'objet

ainsi créé peut aussi être appelé instance de classe.

Pour la crée on utilise la syntaxe new suivi du nom de la classe.

# Principe d’encapsulation
 Attributs
• Les attributs sont les variables membres de la classe.

• Pour déclarer un attribut il faut le précéder par sa visibilité. La visibilité d’un

attribut indique à partir d'où on peut y avoir accès.
Il existe trois types de visibilité:
 Attributs(2/)
• Exemples de déclaration d’attributs

• Cependant, c'est la visibilité private (ou protected qui est considérée

comme extension de private) qui est recommandée.

On parle alors du principe d'encapsulation.

 Encapsulation
• L'encapsulation est un principe fondamental de la POO.

• Il vise à masquer les attributs aux utilisateurs du code (les programmeurs

qui se serviront de la classe par la suite).

• En fait, ce qui est important dans une classe ce sont les attributs.
Les méthodes ne font qu'agir sur ceux ci.

• Le fait d'exposer les attributs aux utilisateur peut compromettre le bon

fonctionnement de la classe.

• Il faut donc les masquer et leur limiter l'accès uniquement de l'intérieur de l

a classe par le biais des méthodes prévues à cet effet.
 Déclaration des méthodes
• Les méthodes sont des fonctions membres. Ce sont elles qui se chargent de
manipuler les attributs et dotent ainsi la classe de son comportement.

• Pour déclarer une méthode il suffit de procéder comme si on déclarait une

fonction en PHP en la précédant par la visibilité qui peut être soit public ou
private.

Une méthode publique est accessible de partout (de l'intérieur comme de

l'extérieur de la classe).

Une méthode privée est accessible seulement de l'intérieur de la classe. Elle

est généralement sollicitée par une autre méthode publique.
Déclaration des méthodes(2/)
 Appel d'attributs et méthodes
• Après avoir créé l'objet, on peut désormais accéder à ses membres
(attributs et méthodes) par le biais de l'opérateur -> (un tiret suivi d'un chevron
fermant).
# Constructeur et destructeur
 Constructeur
• Le constructeur d'une classe est une méthode publique (dans la plupart des
cas).
• Elle est appelée automatiquement au moment de l'instanciation.

• Elle sert généralement à initialiser les attributs et fournir à l'objet créé tout
ce dont il a besoin pour fonctionner.
Cette opération d'initialisation est connue sous le nom d'hydratation.

• Le constructeur est une méthode qui a le même nom que la classe.

Cependant, en PHP on préfère l'identifier par le mot clé __construct() (avec

deux sous-tirets au début).
 Constructeur(2/)
• les attributs sont initialisés tous les trois dans le
constructeur.

• Par conséquent, au moment de l’instanciation ($

mercedes = new Voiture();)

• le constructeur est appelé et les attributs initiali-

sés.

$this est une pseudo-variable qui représente l'objet en cours. Autrement dit, au sein
de l'objet $mercedes la pseudo-variable $this vaut $mercedes, par conséquent:
 Constructeur(3/)

• Le constructeur peut prendre des

paramètres ce qui permet aux objets
d’avoir des valeurs différentes lors de
l’instanciation.

Notez que les variables passées en argument au constructeur ($couleur et $puissance)

n'ont rien à voir avec les attributs du même nom déclarés dans la classe.
 Destruction
• Le destructeur et une méthode publique identifiée par le nom __destruct().
Il est appelé automatiquement par le compilateur lorsqu'il n'y a plus aucune
référence à l'objet en cours.

Autrement dit, le destructeur est appelé quand il n'y a plus aucun appel d'un
membre quelconque de l'objet.
# Constantes de classe, attributs et
méthodes statiques
 Constantes de classe
• Les attributs et méthodes définis dans une classe appartiennent en fait à
l'objet qui sera l'instance de cette classe. On s'est donc servi de l'opérateur ->
pour désigner un membre à partir de l'objet créé.

• Cependant, ont peut spécifier les membres qui appartiennent à la classe et

non à l'objet.
• On appelle ces membres, attributs et méthodes statiques. Pour y accéder o
n se sert de l'opérateur de résolution statique :: appelé simplement double
deux points.
Constantes de classe
• Une constante de classe est un élément
statique par défaut. Son rôle est le même que celui
d'une constante classique déclarée à l'aide de la fo
nction define().

• Pour définir une constante on utilise le mot clé

const suivi du nom de la constante à laquelle on
affecte la valeur souhaitée.

Par convention l'identifiant de la constante est déc

laré en majuscule.
 Attributs et méthodes statiques
• Les attributs et méthodes statiques appartiennent à la classe et non à
l'objet.

• Par conséquent on ne peut pas y accéder par l'opérateur -> mais plutôt par
l'opérateur de résolution de portée :: précédé par le nom de la classe dans l
aquelle ils sont définis.

• Pour spécifier si un membre est statique on déclare le mot clé static après
la visibilité.
 Attributs et méthodes statiques(2/)
• L’appel des attributs et des méthodes statiques a l’intérieur de la classe
peut se faire avec le mot-clé self au lieu du nom de la classe.

• Le mot-clé self désigne la classe courante.

• Mais pas a l’extérieur de la classe.

# Méthodes magiques
 Méthodes magiques
• Les méthodes magiques sont des méthodes prédéfinies et toutes préfixées
par double sous-tirets (__) dans une classe PHP.

• Elle sont appelées automatiquement suite à un événement spécial qui peut

survenir lors de l’exécution.

• Le constructeur et le destructeur sont tous les deux des méthodes

magiques qui s’exécutent automatiquement suite à un événement.

• Le constructeur est exécuté suite à l'instanciation

• Le destructeur quand il n'y a plus de référence à la classe dans le reste du

code.
 Méthodes __get
• Connue par le nom de getter, __get($att) est une méthode qui s’exécute aut
omatiquement quand on appelle un attribut inexistant ou inaccessible.

Par exemple, si on veut accéder à la valeur

d'un attribut privé de l'extérieur de la classe,
le getter anticipe l'erreur et s’exécute
automatiquement. Dans ce cas l'argument $att
sera remplacé par le nom de l'attribut sollicité.
 Méthodes __get
• En général le getter est utilisé pour réellement accéder aux attributs privés
depuis l'extérieur de la classe (d'une manière contrôlée, pour ne pas
rompre le principe d'encapsulation).
 Méthodes __set
• La méthode __set($att,$val) connue sous le nom de setter est appelée
automatiquement quand on essaie de modifier un attribut inexistant ou
inaccessible.
Dans ce cas, l'argument $att reçoit le nom de l'attribut et $val la valeur qu'on
tente de lui affecter.
 Méthodes __isset
• La méthode magique __isset($att) est appelé automatiquement quand on
exécute la fonction isset() en lui passant en paramètre un attribut
inexistant ou inaccessible.

Dans la pratique, on fait en sorte que cette méthode retourne le résultat esco
mpté par la fonction isset(), à savoir true si l'attribut existe et false si l'attribut
n'existe pas.
 Méthodes __toString
• La méthode magique __toString() est appelé automatiquement quand on
tente de traiter un objet en tant que chaîne de caractères
(à l'aide de la structure echo par exemple).

Dans ce cas, cette méthode retourne la chaîne de caractères de notre choix.

# Principe de l’heritage
 Héritage
• L'héritage est un concept fondamental de la POO.

• Pour procéder à l'héritage, on fait appel au mot clé extends comme ceci:
 Héritage et la visibilité Protected
• Le principe d'encapsulation veut que tous les attributs soient privés.

• Mais si on veut hériter d'une classe, alors les attributs privés ne sont plus
réutilisables puisqu'ils sont reconnus uniquement au sein de la classe où ils
sont déclarés.

La visibilité protected a été intégrée pour résoudre ce problème.

En fait, elle se comporte à peu près comme private. Les attributs ne sont
donc pas accessible de n'importe où comme c'est le cas pour public, mais
seulement à l'intérieur de la classe dans laquelle ils sont déclarés et dans les
classes qui héritent de cette classe là
Héritage et la visibilité Protected(2/)
 Surcharge d'une méthode
• La classe fille a la possibilité de redéfinir les méthodes de la classe mère.
Ce phénomène est appelé surcharge de méthode.
 Mot clé parent
Le mot clé self qui fait référence à la classe courante.

Dans l'exemple précédent on a appelé la classe Vehicule par son nom dans la
classe Fille pour appeler statiquement modeDeplacement().

Cette fois on va faire appel au mot clé parent qui désigne la classe dont on a
hérité.

Autrement dit, si nous sommes dans la classe Fille et on veut appeler statique
ment modeDeplacement() de la classe Vehicule, au lieux de mettre
Vehicule :: modeDeplacement(), on peut mettre parent::methode1().
Mot clé parent(2/)
# Classes et méthodes abstraites
(Mot clé abstract)
 Classes abstraites
• Les classes abstraites s'inscrivent davantage dans la sûreté de la
programmation orientée objet.

La première particularité d'une classe abstraite, c'est qu'elle ne peut être insta
nciée (et donc créer un objet).

De cette affirmation, on en déduit logiquement qu'une classe abstraite est déc

larée afin d'être dérivée par des classes concrètes.

• Une classe déclarée abstraire peut aussi définir des méthodes abstraites.
Ces dernières devront obligatoirement être redéfinies dans les classes
dérivées. C'est un moyen de s'assurer que la classe dérivée adoptera le
comportement désiré.
 méthodes abstraites
• Une méthode abstraite est aussi déclarée au moyen du mot-clé « abstract ».
C'est une méthode partiellement définie dans la classe.

• Lorsque l'on déclare une méthode abstraite, on ne définit que son

prototype (sa signature).

Les classes dérivées devront obligatoirement redéfinir entièrement (prototyp

e + corps) toutes les méthodes abstraites de la classe parente.
méthodes abstraites(2/)
# classes et méthodes finales
 Classes et méthodes finales
• Lorsque l'on définit une classe comme « finale », cela signifie qu'elle ne
pourra plus être dérivée par une sous-classe.

Cela implique également que ses attributs et méthodes ne pourront plus être
redéfinis.

En revanche, si l'on applique le mot-clé « final » à une méthode d'une classe,

alors c'est uniquement cette méthode qui ne pourra plus être redéfinie dans
les classes dérivées.

• En interdisant la dérivation d'une classe ou la redéfinition (surchage) des

méthodes d'une classe, cela vous permet de vous assurer que le
développeur ne contournera pas directement la logique que vous avez
mise en place.
Déclaration de classes finales
Déclaration de méthodes finales
 Quelques règles à retenir
• Si une méthode est abstraite alors la classe qui la contient doit être
abstraie aussi.

• Une classe abstraite peut contenir une méthode finale. Celle si ne doit pas
être redéfinie lors de l'héritage.

• Si une classe est finale, il est inutile d'y déclarer une méthode finale.
Dans tous les cas on ne peut pas hériter de la classe.

• Une méthode finale peut figurer dans une classe qui n'est ni finale ni
abstraite.
# Interfaces
 Interface
• Quand on crée une classe, rien ne nous oblige à déclarer telle ou telle
méthode.

Nous sommes libres de déclarer ce qu'on veut avec les noms que l'on veut
(tant qu'ils respectent les spécifications décrites en PHP).

Cependant, il est parfois utile de dicter sa conduite à une classe particulière.

Autrement dit, cette classe doit impérativement contenir une ou plusieurs
méthodes avec les visibilités et les noms souhaités.

Afin de parvenir à ceci, on recourt aux interfaces.

 Interface (2/)
• Une interface se comporte comme une classe abstraite dont toutes les
méthodes sont abstraites.

l'ultime différence entre une classe abstraite et une interface est que les
classes qui vont hériter des classes abstraites constituent des sous familles de
la classe mère, par contre une interface peut être utilisées par des classes
dont les finalités ne sont pas forcément semblables.

Soit la classe Vehicule les classes Filles qui peuvent en hériter sont Voiture,
Camion et Fourgon. Par contre les classes Vehicule et Maison ne sont pas de
la même famille.
Néanmoins chacune d'entre elles peut accueillir une méthode du nom de pein
dre(). C'est là où une interface qui renferme la méthode peindre() peut être
utile.
 Interface (3/)
• Pour définir une interface, on utilise le mot clé interface.

• Pour se servir de l'interface créée, il faut l'implémenter par une classe à l'aid
e du mot clé implements
 Interface (4/)
• Implémenter plusieurs interfaces:

• A l'inverse de l'héritage en PHP, on peut implémenter plusieurs interface si

multanément:
# Traits
 Trait
• Les traits permettent de minimiser le code en réutilisant des méthodes déjà
déclarées sans être obligé d'hériter d'une classe entière.

• Un trait ne peut être ni instancié comme une classe ni implémenté comme

une interface.

• Il s'agit d'un bloc de code qui sera réutilisé par une classe.

• Pour créer un trait on déclare le mot clé trait suivi de son nom.
 Trait(2/)
• Pour se servir du trait Notification dans une classe on procède comme ceci

• Vous avez compris que le code du trait Notification a été réutilisé comme
si'il était déclaré directement dans la classe Operation.

Un trait peut aussi définir des attributs qui seront repris pas la classe qui
l'utilisera.
# Les espaces de noms
(Namespaces)
 Namespace
• En programmation on ne peut pas créer deux fonctions de même nom (de
même pour les classes et les constantes).

• La solution consiste donc soit à renommer nos éléments ou, mieux encore,
à les déposer dans des espaces différents (comme des répértoires sur un
système de fichiers).

On appelle ces espaces des espaces de noms (ou namespaces).

Un espace de nom ou namespace représente un moyen de séparer ses

éléments au sein du code de telle sorte à éviter les conflits (ou collisions).

Ces collisions sont dues à des duplications de noms (ou identifiants)

d'éléments comme les fonctions, les constantes ou les classes.
 Namespaces(2/)
• Pour définir un namespace on utilise le mot-clé namespace suivi du nom de
celui-ci. Le nom peut être choisi de la même façon qu'une fonction (lettres,
chiffres et caractères souligné).
 Thank you
Insert the title of your subtitle Here