École régionale du numérique - Développement d'une application Web

2018 – 2019

Cours PHP
n°4

M. Ducongé - Barrère 1/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019

L’héritage ................................................................................................................................................... 3
Introduction ......................................................................................................................................................... 3
Définition ............................................................................................................................................................. 3
Intérêt de l’héritage de classe.............................................................................................................................. 3
Relation entre classes .......................................................................................................................................... 3
Déclarer un héritage de classe ............................................................................................................................. 4
Visibilité « Protected » ......................................................................................................................................... 4
Encapsulation....................................................................................................................................................... 4
Contexte statique et opérateur de résolution de portée ..................................................................................... 5
Appel externes ................................................................................................................................................ 5
Appel internes ................................................................................................................................................. 5
Appel au parent .............................................................................................................................................. 5
Surcharge de méthode ......................................................................................................................................... 5
Abstraction........................................................................................................................................................... 6
Classes ............................................................................................................................................................. 6
Méthodes ........................................................................................................................................................ 6
Classes finales ...................................................................................................................................................... 7

Patron de conception ................................................................................................................................. 8

Introduction ......................................................................................................................................................... 8
Singleton .............................................................................................................................................................. 8
Composition d’une classe singleton ..................................................................................................................... 8
Création de la classe singleton ............................................................................................................................ 9

M. Ducongé - Barrère 2/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019
L’HERITAGE

Introduction

L'héritage est un des grands principes de la programmation orientée objet et PHP l'implémente
dans son modèle objet. Ce principe va affecter la manière les relations interclasses et permettre
d’optimiser une application.

Définition

Quand on parle d'héritage, on dit que la classe B hérite de la classe A. La classe A est donc
considérée comme la classe mère et la classe B est considérée comme la classe fille.

Une classe mère peut avoir plusieurs filles, mais une classe fille ne peut pas avoir plusieurs
mères.

Intérêt de l’héritage de classe

L’héritage permet de segmenter et spécialiser les classes d’une application. De plus, cette
relation va permettre de déclarer de nouveaux attributs et de nouvelles méthodes pour la
classe dérivée, qui viennent s'ajouter à ceux et celles héritées.

Relation entre classes

Lorsque vous étendez une classe, la classe fille hérite de toutes les méthodes publiques et
protégées de la classe parente. Tant qu'une classe fille n'écrase pas ces méthodes, elles
conservent leur fonctionnalités d'origine.

Cet héritage permet de regrouper des fonctionnalités et propriétés communes aux classes
« Mammifères », « Poissons », « Oiseaux », « Reptiles » et « Batraciens », tout en permettant
la mise en place de fonctionnalités supplémentaires dans les classes enfants.

Par exemple, la classe « Oiseaux » hérite de tout le contenu déclaré en « public » et

« protected » implémenté dans la classe « Vertebres ».

Il est tout à fait possible de rajouter des niveaux d’héritage afin de faire un héritage multiple et
optimiser son application comme ci-après.

M. Ducongé - Barrère 3/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019

Déclarer un héritage de classe

Pour étendre une classe, il faut utiliser le mot-clé « extends » suivi du nom de la classe parente.

// Création d'une classe simple.

class Vehicule{
}

// La classe Moteur hérite des attributs et méthodes de Vehicule.

class Moteur extends Vehicule {
}

// La classe TractionHumaine hérite des attributs et méthodes de Vehicule.

class TractionHumaine extends Vehicule {
}

De cette manière, il sera possible de créer plusieurs filles héritant de la même mère. Il est
également commun de voir une classe fille/mère. C’est à dire qu’elle est l’enfant d’une classe
mais aussi une mère d’une autre classe au minimum.

Visibilité « Protected »

Lorsqu’on utilise l’héritage de classes, un autre niveau de visibilité peut être utilisé que celui vu
précédemment (« public » et « private »), ils s’agit du mot-clé « protected ». L'accès aux
éléments protégés est limité à la classe elle-même et aux classes enfants.

Encapsulation

Le principe de base de l’encapsulation est de cacher des informations (mot-clé « private » et

« protected ») afin de ne pas pouvoir ni les modifier ni les consulter directement. Autrement
dit, il devra appeler des méthodes pour interagir avec des données, ce sont les « getter » et
« setter », par convention, le nom des méthodes commencent par « get » et « set ».
Il est vivement recommandé de suivre cette méthodologie pour pouvoir contrôler les données
qui seront affectées aux propriétés.

M. Ducongé - Barrère 4/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Contexte statique et opérateur de résolution de portée

Les éléments statiques sont des éléments de classe et non pas des éléments d'instances, ils
sortent du modèle objet mais restent accessibles.
Pour ce faire, il faut utiliser l'opérateur :: , appelé opérateur de résolution de portée. Il permet
d'accéder à des éléments « static » externes ou internes à une classe.
Appel externes
L'opérateur de résolution :: permet de d'accéder à un élément « static » (constante, variable
ou méthode statique) d'une classe.

NomDeClasse::NOMDECONSTANTE ;
NomDeClasse::$nomDeVariableStatique ;
NomDeClasse::nomDeMethodeStatique() ;
Appel internes
Le mot self et l'opérateur de résolution permettent d'accéder aux éléments « static » de la
classe elle-même.

self::NOMDECONSTANTE ;
self::$nomDeVariableStatique ;
self::nomDeMethodeStatique() ;
Appel au parent
Le mot parent et l'opérateur de résolution permettent d'accéder aux attributs et méthodes
« static » du parent.

parent::NOMDECONSTANTE
parent::$nomDeVariable ;
parent::nomDeMethode() ;

Surcharge de méthode

La surcharge de méthode consiste à modifier la méthode créée dans la classe parente depuis
une classe enfant.

class Magicien extends Personnage{

public function gagnerExperience(){
// On appelle la méthode gagnerExperience() de la classe parente
parent::gagnerExperience();
}
}
Si une fonction portant le même nom est déclarée dans la classe mère et fille, c’est la méthode
de classe fille qui sera appelée.

M. Ducongé - Barrère 5/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Abstraction

Classes
Jusqu'à présent, nous avons vu que toutes les classes peuvent être instanciées. Or, il est
nécessaire parfois de rajouter des contraintes à la classe comme bloquer la création d’objet car
inutile dans l’application. On parle alors de classe abstraite.

Par exemple, dans une application permettant de créer des personnages, nous avons besoins
des classes pour créer des guerriers et des magiciens. Par conséquent, aucun intérêt de pouvoir
créer des objets de la classe personnage, elle sera donc abstraite.

Pour déclarer une classe abstraite, il faut utiliser le mot-clé « abstract » devant le nom de la
classe.

// la classe Personnage est abstraite.

abstract class Personnage{
}

// Création d'une classe Magicien héritant de la classe Personnage.

class Magicien extends Personnage
{
}

Par exemple si vous exécuter le code ci-dessous vous aurez une erreur vous indiquant que la
classe personnage n’est pas instanciable.
$magicien = new Magicien();// Tout va bien, la classe Magicien n'est pas abstraite.
$perso = new Personnage(); // Erreur fatale car on instancie une classe abstraite.
Méthodes
Il est possible de déclarer des méthodes abstraites pour forcer toutes les classes filles à
implémenter cette méthode.
Seul le prototype de la méthode doit être écrit dans la classe abstraite puisque la méthode sera
obligatoirement implémentée dans les classes enfants. On ne doit donc spécifier aucune
instruction.

Le prototypage est constitué de :

Visibilité + function + nomDeLaMethode + parenthèses avec ou sans paramètres +
point-virgule.

Attention toute méthode abstraite implique que la classe soit également abstraite sinon une
erreur sera levée.

Voir code page suivante.

M. Ducongé - Barrère 6/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019
abstract class Personnage {
// On va forcer toute classe fille à écrire cette méthode car chaque
// personnage frappe différemment.
abstract public function frapper (Personnage $perso);

// Cette méthode n'aura pas besoin d'être réécrite.

public function recevoirDegats (){
// Instructions.
}
}

class Magicien extends Personnage{

// On écrit la méthode « frapper » du même type de visibilité que la méthode
// abstraite « frapper » de la classe mère.
public function frapper (Personnage $perso){
// Instructions.
}
}

Classes finales

Le concept des classes et méthodes finales est exactement l'inverse du concept d'abstraction.
Si une classe est finale, vous ne pourrez pas créer de classe fille héritant de cette classe. Ce
concept est peu utilisé puisqu’une application tend très souvent à évoluer et donc à être
modifiée et potentiellement avoir un/des enfant(s).

Pour ce faire, il faut ajouter le mot-clé « final » devant le mot-clé « class ».

final class Guerrier extends Personnage

{
}

M. Ducongé - Barrère 7/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019
PATRON DE CONCEPTION

Introduction

Un patron de conception est un concept qui permet de par sa forme et sa structure, de

résoudre des problématiques dans une application.

Singleton

Le Singleton, en programmation orientée objet, répond à la problématique de n'avoir qu'une

seule et unique instance d'une même classe dans un programme.

Par exemple, dans le cadre d'une application web dynamique, la connexion au serveur de base
de données doit être unique. Il suffit donc par exemple de créer l'unique objet représentant
l'accès à la base de données, de stocker la référence à cet objet dans une variable globale afin
que l'on puisse y accéder de n'importe où.

Composition d’une classe singleton

La conception d’un singleton tiens en quelques contraintes :

- Le singleton doit être une classe instanciable
- Elle doit contenir un attribut privé et statique qui aura pour valeur l’instance de la classe
- Un constructeur privé pour ne pas créer d’autres objets
- Une méthode statique pour pouvoir récupérer l’instance unique

L’avantage est que l’instance de classe est statique donc accessible partout dans l’application
peu importe le contexte. Cela répond exactement à la problématique de rendre accessible
une même connexion à une BDD dans toute une application.

M. Ducongé - Barrère 8/9

 École régionale du numérique - Développement d'une application Web
2018 – 2019
Création de la classe singleton

class BDD {

/*
* Permet de stocker l’instance de la classe
*/
private static $instance = null;

/*
* Le constructeur est en privé pour ne pas créer d’autre objets en dehors de la
* classe
*/
private function __construct() {
echo 'objet créé<br/>';
}

/*
* Méthode qui crée l'unique instance de la classe si elle n'existe pas encore puis la
* retourne.
*/
public static function getInstance() {

if(is_null(self::$instance)) {
self::$instance = new BDD();
}

return self::$instance;
}
}

// Récupération de l’instance de classe

$singletonBDDa = BDD::getInstance();
$singletonBDDb = BDD::getInstance();

echo "<pre>";
var_dump($singletonBDDa, $singletonBDDb);
echo "</pre>";

A l’exécution du script, vous obtiendrez alors le résultat suivant. Les deux variables
$singletonBDDa et $singletonBDDb auront pour valeur le même objet.

objet créé
object(BDD)#1 (0) {}
object(BDD)#1 (0) {}

M. Ducongé - Barrère 9/9