La Programmation Orientée Objet

en PHP
partie 1 : les bases

Dr N. BAME
 Introduction
• Contrairement des langages comme Java ou C++, les premières
versions du langage PHP n’ont pas été conçues pour la POO

• Les premiers éléments de POO ont été intégrés dans la version 3

• PHP4 puis surtout PHP5 ont introduit de véritables concepts pour

la POO, notamment la notion d’héritage et d’encapsulation

• Il est maintenant possible de programmer très efficacement en

POO avec PHP 7.

• La grande majorité des librairies de code sont disponibles sous

forme de classes
 Intérêt
• Permet
– de rassembler autour d’un même objet (concept), une
définition, des attributs et des méthodes d’action
– de réutiliser des objets existants en les complétant par
ce qui est nouveau
• D’où des avantages liés à :
– la clarté du code
– la modularité
– la réutilisabilité
– l’interopérabilité
 Concepts de base

• Classe
• Objets
• Propriétés
• Méthodes
• Encapsulation
• Constructeur
• Destructeur
• …
 Concept : Classe
• Une classe peut être vue comme une abstraction.
– C’est un modèle de donnée
– On peut la voir comme une famille d’objets
• Elle contient des propriétés et des méthodes :
Propriété = variable de classe
Méthode = fonction de classe

• L'environnement de la classe est protégé :

– Les propriétés et les méthodes peuvent être déclarées
comme non accessibles en dehors de la classe.
– Les propriétés ne se mélangent pas aux variables globales.
class ClassName
{ … }
 Concept : Classe
• Déclarer une classe class Voiture
{
//contenu de la classe
}
• Attributs
– Le contenu de la classe est structuré en deux parties
– La première partie permet de déclarer les attributs
– Les attributs sont déclarés en utilisant la syntaxe des
variables et un des mots-clés suivant : public, private ou
protected class Voiture
Exemple {
public $marque;
}
 Concept : Classe
• Il est possible d’utiliser une valeur par défaut
class Voiture {
public $marque=’Toyota’;
}
• Méthodes
– La deuxième partie du contenu d’une classe permet la
déclaration des méthodes
– Ces méthodes se déclarent exactement comme des
fonctions class Voiture {
public $marque=’Ferrari’;
function freiner($force_de_freinage){
//instructions pour faire freiner
}
}
 Remarques
1. Le nombre de variables déclarées dans une classe
n’est pas limité.

2. Le nom des méthodes ne doit pas être le même que

celui de la classe qui les contient.
• Il ne doit pas non plus commencer par deux caractères de
soulignement (__),
cette notation étant réservée à certaines fonctions particulières
de PHP.

3. Le bloc de code de la classe ne doit rien comporter

d’autre que ce qui est indiqué ci-dessus.
– En particulier, il ne doit contenir aucune fonction ou
instruction PHP située en dehors des méthode de la classe ou
de la déclaration des propriétés.
 Exemple de classe
class Etudiant
{ private $nom;
private $prenom;

public function getNom()

{return $this->nom;}

public function setNom($newName)

{$this->nom= $newName;}
…
public function afficher()
{echo $this->nom.’ ‘.$this->prenom;}
}
 Concept : Objet
• Un objet est une instance de classe.
• Avec une classe, on peut créer autant d'objets qu'on
veut
– sauf si dans l'implémentation on décide de contrôler
l'instanciation
• Une classe est une déclaration, alors qu'un objet est
contenu dans une variable, créé à partir de la classe
avec le mot clé « new ».
<?php
$myObject = new ClassName();
?>
Remarque :
le code de définition de la classe doit être dans le même script ou
inclus au début du script à l’aide des fonctions require() ou
include()
 Concept : Objet
Accès aux propriétés d’un objet
• Pour accéder, aussi bien en lecture qu’en écriture, à
la propriété prop d’un objet, on utilise : –>
$myObject–>prop;
ou encore :
$myObject–>prop[$i];
si la propriété prop de l’objet est un tableau

• Pour appeler une méthode de l’objet, appliquez la

même notation :
$myObject–>nom_fonction();
 Exemple d’objet
<?php
$etud1= new Etudiant();
$etud1->setNom(‘Diop’);
$etud1->setPrenom(‘Seynabou’);
$etud1->afficher();
?>
Encapsulation
 Accès aux propriétés de la classe
• Les propriétés de la classe ne sont pas accessibles
directement à l’extérieur du script qui définit la
classe
– De même pour les méthodes
• Cette particularité est nommée encapsulation et
permet en quelque sorte de protéger la « cuisine »
interne, conçue pour créer une classe
 Accès aux propriétés dans la classe
• Pour qu’une méthode accède aux propriétés
déclarées dans la classe, elle doit y faire appel à
l’aide de la syntaxe suivante :
$this–>mavar
• La pseudo-variable $this fait référence à l’objet en
cours, ce qui permet d’utiliser la variable $mavar
dans la méthode
 Accessibilité des propriétés : 3 options
• public
Permet l’accès universel à la propriété, aussi bien dans la
classe que dans tout le script, y compris pour les classes
dérivées.
• protected
– La propriété n’est accessible que dans la classe qui l’a
créée et dans ses classes dérivées (héritage).
• private
– C’est l’option la plus stricte : l’accès à la propriété n’est
possible que dans la classe et nulle part ailleurs
 Accessibilité des méthodes
On retrouve les 3 options
– public
• La méthode est utilisable par tous les objets de la classe et de
ses classes dérivées
– protected
• La méthode est utilisable dans sa classe et dans ses classes
dérivées, mais par aucun objet
– private
• La méthode n’est utilisable que dans la classe qui la contient,
donc ni dans les classes dérivées, ni par aucun objet

• NB : Tout appel d’une méthode en dehors de son champ de

visibilité provoque une erreur fatale

• Utiliser la visibilité private ou protected pour les attributs

• Utiliser la visibilité public pour les méthodes
 Constructeur (1)
• Méthode qui est exécutée lors de l'instanciation de la classe.
• Lorsque l’on crée un objet, celui-ci est vide au départ.
– De ce fait, ces propriétés ne disposent pas de valeurs.
– il existe un constructeur par défaut pour chaque classe en PHP
• Il est toujours possible de créer son propre constructeur
• la création d’un constructeur écrasera le constructeur par
défaut
• En définissant un constructeur pour la classe, on pourra
initialiser les valeurs des propriétés de tout objet à sa
création.
– Permet de créer des objets et de définir leurs propriétés en une
seule opération
• Les actions du constructeur se définissent dans la méthode
magiques : __construct(…)
 Constructeur (2)

void __construct($arg1,…,argN)
Méthode :
– dite « méthode magique » comme toutes celles qui
commencent par « __ »
– porte le même nom, quelle que soit la classe, ce qui
permet des mises à jour sans avoir à modifier le nom du
constructeur
– ne retourne aucune valeur
– appelée automatiquement lors de la création de l’objet
 Exemple
<?php class Etudiant
{
private $nom;
private $prenom;

public function __construct($pname, $name)

{
$this->prenom= $pname;
$this->nom= $name;
}
…
}
?>
…
<?php
$Etud2 = new Etudiant( ‘Mamadou’, ‘Ndiaye’);
?>
 Destructeur
void __destruct()
Méthode :
– s’utilise sans paramètre
– ne retourne aucune valeur
– appelée automatiquement soit après la destruction
explicite de l’objet avec la fonction unset(), soit après la
fin du script
– contient typiquement des instructions qui permettent
de gérer proprement la destruction d’un objet, comme
la fermeture explicite d’un fichier ou d’une connexion à
une base de données
 Constantes
• PHP permet de définir des constantes propres à la classe à
l’aide du mot-clé const suivi du nom de la constante puis de sa
valeur.
const MYCNST = Valeur;

• Les constantes ne sont pas accessibles à l’extérieur de la classe

avec leur seul nom mais avec la notation
nom_classe::MYCNST
• Pour utiliser une constante de classe à l’intérieur de la classe elle-
même, il faut utiliser la notation self::MYCNST.

• Utilisation d’une constante

o Dans la classe
self::MYCNST;
o En dehors de la classe :
className::MYCNST;
Exemple : constante
 Propriétés et méthodes statiques
• La notion de propriété et de méthode statique permet d’accéder
à ces éléments sans qu’il ait besoin de créer une instance de la
classe.
• Pour déclarer une propriété ou une méthode statique, vous
devez utiliser le mot-clé static.
private static $MA_VAR;
public static function my_function(){…}

Utilisation
• La propriété ou méthode est celle de la même classe, ou encore
self::$propriete self::maFonction()
• La propriété ou méthode est celle d’une autre classe.
nomclasse::$propriete nomclasse::maFonction()
• Notez qu’il faut conserver le signe $ pour désigner la propriété.
 Remarques
• Si vous créez un objet instance de la classe, la
propriété déclarée static n’est pas accessible à
l’objet en écrivant le code $objet->propriete.
– A la place : $objet::$propriete
• Par contre, les méthodes statiques sont
accessibles par l’objet avec la syntaxe habituelle
$objet->méthode() ou avec $objet::méthode() .

• this vs self
– on utilise $ avant this mais pas avant l’attribut qui le suit
– on utilise $ avant l’attribut de la classe qui suit self mais
pas avant self
 La méthode magique : __toString
• Soit
$pers1= new Personne(‘Mamadou’, ‘Ndiaye’)
echo $pers1;
• Si on essaye d’afficher cet objet dans la page ⇒ erreur fatale :
Object ofclass Personne could not be converted to string

• Pour résoudre ce problème, on ajoute une méthode

__toString()
public function __toString(): string
{
return $this->nom . " " . $this->prenom;
}

Ainsi le résultat de l’instruction précédente est :

echo $pers1; /* affiche Ndiaye Mamadou */
 Typage des paramètres et des méthodes
• contrôle de type de paramètre
– PHP est un langage de programmation faiblement typé
– Par exemple, on peut affecter une chaîne de caractère à
une variable qui attendait un nombre
• Solution avec PHP 7 : typer les méthodes et les
paramètres
 Récapitulatif
• On recommande d’avoir une seule classe par
fichier.
• Une classe peut avoir comme attribut un objet
d’une autre classe (définie dans un deuxième
fichier).
• Il faut inclure cette autre classe (avec include ou
require) pour l’utiliser
• Et si dans un fichier on utilise plusieurs classes,
Faut-il les inclure toutes une par une ?
• Non on peut utiliser la fonction
spl_autoload_register pour faire l’auto-chargement
 Chargement et auto-chargement
• De manière générale dans les applications orientées objet on
crée un fichier source par définition de classe.
• Un des plus gros inconvénients de cette méthode est d'avoir à
écrire une longue liste d'inclusions de fichier de classes au
début de chaque script :
– une inclusion par classe.

• La fonction spl_autoload_register() enregistre un nombre

quelconque de chargeurs automatiques,
• ce qui permet aux classes et aux interfaces d'être
automatiquement chargées si elles ne sont pas définies
actuellement.
– En enregistrant des auto-chargeurs, PHP donne une dernière
chance d'inclure une définition de classe ou interface.
• L'auto-chargement n'est pas disponible si vous utilisez PHP en
mode interactif CLI.
 spl_autoload_register
• spl_autoload_register : enregistre une fonction en
tant qu'implémentation de __autoload()
• Au tout début du fichier, appeler la fonction
spl_autoload_register qui prend comme paramètre
un callback
• Syntaxe :
spl_autoload_register ([ callable $autoload_function ) : bool
• exemple spl_autoload_register( function ($class ) {
include_once($class . ’.php’);
} );
• La fonction précédente va scanner tous les fichiers :
– y compris ceux qui ne contiennent pas de classe.
 Remarque
• Une bonne pratique consiste à regrouper les fichiers
contenant de classes dans un répertoire
– classes par exemple et de scanner seulement ce dossier.
• Et Modiier l’appel de spl_autoload_register après avoir
déplacées toutes les classes dans un répertoire classes
spl_autoload_register( function ($class ) {
include(‘classes/’.$class . ’.php’);
} );
• On peut aussi créer plusieurs répertoires models,
controllers...
– Et utiliser plusieurs fois la fonction spl_autoload_register
pour limiter la zone de recherche
<?php Exemple
// function __autoload($class) {
// include 'classes/' . $class . '.class.php';
// }

function my_autoloader($class) {
include 'classes/' . $class . '.class.php';
}

spl_autoload_register('my_autoloader');

// Ou, en utilisant une fonction anonyme à partir de PHP 5.3.0

spl_autoload_register(function ($class) {
include 'classes/' . $class . '.class.php';
});

?>
Héritage
 Héritage
• L'héritage consiste à utiliser une classe parente et
une ou plusieurs classes filles qui héritent des
propriétés et méthodes de la classe parente.
• Exemple
– si vous avez une classe Vehicule,
– vous pouvez avoir une classe Voiture qui hérite de
certaines propriétés de la classe Vehicule,
– ainsi qu'une autre classe Moto qui va hériter de
certaines propriétés de la classe Voiture tout en
ajoutant des propriétés propres.
• Le mot utilisé pour dire à PHP qu'une classe hérite
d'une autre est le mot-clé extends.
 Héritage
• L'héritage permet de hiérarchiser des classes.

• Les classes parentes sont génériques, elles mettent en place des

fonctionnalités communes à une ou plusieurs classes.

• Les classes filles sont spécifiques, elles héritent des fonctionnalités

des classes parentes.

class ClasseFille extends ClasseParente

{
…
}

Remarque
• Une classe ne peut hériter que d’une seule classe
• L’héritage multiple est donc non-autorisé.
 Exemple d’héritage
<?php
class Thesard extends Etudiant
{
private $anneeThese;
private $NbArticles;
…
}
?>
 Surcharge de méthodes
• En supposant une classe Voiture qui étend les
propriétés de la classe Vehicule,
• Nous pouvons surcharger le constructeur avec de
nouvelles propriétés qui cette fois seront propres à
la classe Voiture :

Attention
– Si vous surchargez une méthode, sa visibilité doit être
la même que dans la classe parente
• Si tel n'est pas le cas, une erreur fatale sera levée.
– Par exemple, vous ne pouvez pas surcharger une
méthode publique en disant qu'elle est privée.
 parent
• Permet de réutiliser le code de la méthode de la super-
classe
• L’appel au constructeur de la super-classe n’est pas
implicite, il faut le spécifier :
class MySuperClass {
public function __construct($a) { instruction1 }
}
class MyClass extends MySuperClass
{
public function __construct($a) {
parent:: __construct($a - 1);
…
}
}
 Exemple
class Vehicule
{
/*** Déclaration des attributs*/
protected $prix; //On souhaite que les classes qui en héritent puissent y accéder
/**
* Cette méthode un peu spéciale est le constructeur.
*/
public function __construct(int $prix_vehicule)
{
$this->prix = $prix_vehicule;
}
/**
* Cette méthode permet de modifier le prix du véhicule
*/
public function modifier_prix(int $nouveau_prix)
{
$this->prix = $nouveau_prix;
}
}
class Voiture extends Vehicule
{
/*** Déclaration des attributs*/
private $climatisation;
/*** Constructeur de la classe Voiture */
public function __construct( int $prix_vehicule, bool $clim)
{
//On appelle le constructeur de la classe Vehicule en lui fournissant
le prix
parent::__construct( $prix_vehicule );
$this->climatisation = $clim;
}
}

Pour utiliser une méthode parente dans une classe fille, on

utilise le mot-clé parent suivi de l'opérateur de résolution de
portée «::».
 Exemple
• Voici ce que ça donne au niveau de l'instanciation :

//On crée une voiture valant 17000 euros et ayant la climatisation

$voiture = new Voiture(17000, TRUE);
//On peut modifier le prix de la voiture
$voiture->modifier_prix(15000);

• Comme vous pouvez le constater, on peut accéder à la classe

parente comme si on accédait à la classe Voiture avec la
méthode modifier_prix().

• Si vous aviez mis la méthode modifier_prix() en accès privé,

vous n'auriez pu effectuer la modification directement.
• Le niveau de protection le plus restrictif permettant cette
modification est le niveau protected.
 Exemple
• Un enseignant a un numéro, un nom, un prénom et
un salaire
• Un étudiant a aussi un numéro, un nom, un prénom
et un niveau
• Sémantiquement, enseignant et étudiant sont une
sorte de personne
• En plus, les deux partagent plusieurs attributs tels
que numéro, nom et prénom
• Donc, on peut utiliser la classe Personne puisqu’elle
contient tous les attributs numéro, nom et prénom
• Les classes Etudiant et Enseignant hériteront donc
(extends) de la classe Personne
 Remarque
• Pour connaître la classe d’un objet, on peut utiliser
le mot-clé instanceof
 Overloading
• La surcharge n’est pas autorisée en PHP,
• c’est-à-dire on ne peut pas définir plusieurs
méthodes avec des signatures (nombre et type de
paramètre) différentes.
 La redéfinition en PHP
• On peut redéfinir
– les attributs
– les méthodes

– On peut aussi redéfinir le setter et le getter de l’attribut

$ nom (ce n’est pas obligatoire).
La redéfinition en PHP
 Exercice
• Créer un objet de type Etudiant, un deuxième de
type Enseignant et un dernier de type Personne
stocker les tous dans un seul tableau.
• Parcourir le tableau et afficher pour chacun soit le
numero s’il est personne, soit le salaire s’il est
enseignant ou soit le niveau s’il est étudiant.
Classe abstraite
 Classe abstraite
• On a vu que l'on pouvait instancier n'importe quelle classe
afin de pouvoir exploiter ses méthodes.
• Sachez qu'il est possible aussi d'empêcher quiconque
d'instancier telle classe.
– C'est le principe d'abstraction.
• La définition de classes abstraites permet de définir des
types qui ne peuvent pas être instanciés, seulement
dérivés.
– On ne pourra pas se servir directement de la classe.
– La seule façon d'exploiter ses méthodes sera de créer une ou
plusieurs classes héritant de la classe abstraite.
• Cela permet d’établir une hiérarchie des classes utilisant
des méthodes qui devront être définies plus tard (lors de la
dérivation).
 Classe abstraite
• Si une seule méthode est abstraite, la classe doit
l’être.
• Abstraction possible à plusieurs niveaux d’héritage
• Méthodes : accessibilité private impossible
• Mot clef abstract : abstract class NomClasse
{
// le code
}
 Classe abstraite
abstract class Personne{
// attributs
...
// méthodes
...
}
$Pers = new Personne();
//ça génère une erreur fatale
 Méthode abstraite
• Il est aussi possible de définir une méthode abstraite.
• C’est une méthode non implémentée (sans code ⇒ sans
accolades). Nous devons juste préciser :
– sa visibilité (public, protected ou private).
– sa signature (nom et type de paramètres) [si elle prend de
paramètres].
abstract public function nomMethode();
• Une méthode abstraite doit être déclarée dans une classe
abstraite.
• Dans ce cas, vous forcerez toutes les classes filles à redéfinir
cette méthode.
– Si tel n'est pas le cas, une erreur fatale sera levée.
– Puisque l'on force la classe fille à écrire la méthode, on ne doit
spécifier aucune instruction dans la méthode, on déclarera juste
son prototype :

abstract public function frapper($perso);

 Exemple
abstract class FormeGeo {
abstract public function surface( ) { }
abstract public function perimetre( ) { }
}

• La classe FormeGeo ne permet pas d’instancier des objets.

– Il faut dériver la classe par exemple la classe Carre qui dérive la classe
FormeGeo.
• La classe dérivant une classe abstraite doit fournir les définitions
pour les méthodes abstraites.
Interface
 Interface
• Modèle pour une classe
• Classe totalement abstraite sans attribut (non constant)
– comme une classe abstraite (impossible de l’instancier) dont
toutes les méthodes sont abstraites qui n’a pas d’attribut
– Pas besoin du mot-clé abstract pour les méthodes d’une interface
• Toutes les méthodes d’une interface doivent être publique

• Une classe implémentant une interface doit implémenter

toutes les méthodes déclarées par l’interface.
– un protocole, un contrat : toute classe qui hérite d’une interface
doit implémenter toutes ses méthodes

• L’utilisation des interfaces permet d’apporter une

standardisation des projets tout en apportant un mécanisme
permettant de supporter une certaine forme d’héritage
multiple.
• déclarée avec le mot-clé interface
 Interfaces
• Syntaxe
interface NomInterface
{
...
}
• On crée l’interface qui précise la liste des méthodes que la classe
devra implémenter.

interface Courriel {
public function send( );
}
 Interfaces
• Pour hériter d’une interface, on utilise le mot-clé
implements

class Test implements Courriel {

// données et méthodes membres…
public function send( ) { // la méthode à implémenter…
}
}
 Remarques
• Une interface peut hériter de plusieurs autres
interfaces (mais pas d’une classe)

• Pour cela, il faut utiliser le mot-clé extends et pas

implements car une interface n’implémente jamais
de méthodes.

• Une classe peut implémenter plusieurs interfaces.

 class Voiture implements PeutAvancer, PeutTourner
interface PeutAvancer {
{ public function avance()
public function avancer(); {
public function freiner(); echo "on avance";
} }
public function freine()
interface PeutTourner {
{ echo "on freine";
public function tourneGauche(); }
public function tourneDroite(); public function tourneGauche()
} {
echo "on tourne à gauche";
}
public function tourneDroite()
{
echo "on tourne à droite";
}
function klaxonner()
{
echo "pimp pimp pimp!!!<br />";
}
}
 Hériter des interfaces
• Comme pour les classes, vous pouvez hériter vos
interfaces grâce à l'opérateur extends.
• Vous ne pouvez réécrire ni une méthode ni une constante
qui a déjà été listée dans l'interface parente.
interface iA
{ class MaClasse implements iC
public function test1(); {
} // Pour ne générer aucune erreur, on doit
interface iB extends iA //écrire les méthodes de iC et aussi de iA
{ public function test1()
public function test1 ($param1, $param2); {
// Erreur fatale : impossible de }
// réécrire cette méthode public function test2()
} {
interface iC extends iA }
{ }
public function test2();
}
 Hériter des interfaces
• Contrairement aux classes, les interfaces peuvent
hériter de plusieurs interfaces à la fois.
• Il vous suffit de séparer leur nom par une virgule.
Exemple : interface iA
{
public function test1();
}
interface iB
{
public function test2();
}
interface iC extends iA, iB
{
public function test3();
}
 Abstract VS Interface
• Aucun code n’est présent dans une interface
• Une interface est donc une classe abstraite qui ne
contiendrait que des méthodes abstraites
• Une classe ne peut dériver que d’une classe
abstraite mais peut implémenter plusieurs
interfaces
 Fonctions utiles pour les classes
• get_declared_interfaces() : retourne un tableau
contenant toutes les interfaces déclarées
• class_implements() : retourne les interfaces
implémentées par une classe ou une interface donnée
• class_exists() : vérifie si une classe a été définie
• interface_exists : vérifie si une interface existe
if (interface_exists(’Imposable’)) {
class Personne implements Imposable
{
....
}
}
Finalisation
 Finalisation
• Le mot-clé final a des sens légèrement différents
suivant le contexte,
• mais en général il signifie « Cela ne peut pas
changer ».
• Vous pourriez vouloir empêcher les changements
pour deux raisons : conception ou efficacité.
 Classe finale
• Une classe entière est finale (en faisant précéder sa
définition par le mot-clé final) stipule que nous ne pouvons
pas hériter de cette classe ou permettre à qui que ce soit
de le faire. final class NomClasse {
// le code
• En d'autres mots, }
– soit la conception de cette classe est telle que nous n’aurons
jamais besoin de la modifier,
– soit pour des raisons de sûreté ou de sécurité nous ne voulons
pas qu'elle soit sous-classée (héritée).
– Ou alors, nous pouvons avoir à faire à un problème d'efficacité, et
nous voulons nous assurer que toute activité impliquant des
objets de cette classe sera aussi efficace que possible.
• Une classe finale est donc une classe qui ne peut pas être
héritée.
 Méthodes finales
• Les méthodes finales permettent de mettre un «
verrou » sur la méthode pour empêcher toute
sous-classe de la redéfinir.
– Ceci est fait pour des raisons de conception quand nous
voulons être sûrs que le comportement d'une méthode
est préservé durant l'héritage et ne peut pas être
redéfini.
– Toutes les méthodes privées sont implicitement finales.
• Parce que nous ne pouvons pas accéder à une méthode
privée, nous ne pouvons pas la surcharger.
• Nous pouvons ajouter le mot-clé final à une méthode privée,
mais cela n'apporte rien de plus.

• Une méthode finale est donc une méthode qui ne

peut pas être redéfinie.
 Exemples
class Voiture extends Vehicule
{
final function avancer()
{
echo "on avance";
}
}

final class Voiture extends Vehicule

{
public function avancer() // erreur fatale
{
echo "on avance";
}
}
Exemples
 Remarques
• Une classe abstraite ne doit pas forcément contenir
une méthode abstraite
• Une classe finale ne doit pas forcément contenir
une méthode finale
• Une méthode finale ne doit pas forcément être
dans une classe finale
 Fonctions utiles pour les classes
• get_class($obj) : retourne le nom de la classe de l’objet
$obj
• get_class_methods(NomClasse) : retourne un tableau
contenant les méthodes de la classe NomClasse
• class_exists(NomClasse) : vérifie si la classe NomClasse
existe
• get_object_vars($obj) : retourne un tableau contenant
les attributs de l’objet ($obj)
• get_parent_class($obj) : Retourne le nom de la classe
mère d’un objet $obj
• autres : is_a, is_subclass_of, method_exists,
property_exists...