Développement Web avancé

Ch. 3 : PHP objet

Enseignante : Rim REKIK
Année universitaire : 2023-2024
• Introduction
• Classe
– Définition
– Construction d’un objet
– Visibilité des propriétés et des méthodes
– Héritage
– Méthodes magiques
– Propriétés et méthodes statiques
– Constante de classe
– Abstraction de classe
– Méthodes et classes finales
– Parcours d’objets
• Exceptions
• Activité

PHP objet 2
• Le développement objet consiste à définir des
briques logicielles représentant des objets
(des concepts, des idées ou des entités) ainsi
que leurs interactions.
• PHP inclus un modèle objet complet.
– Certaines de ses fonctionnalités sont : la visibilité,
les classes et méthodes abstraites, etc.

PHP objet 3
• Une classe définit un modèle, un moule, à
partir duquel tous les objets de la classe
seront créés.
• Une classe peut contenir :
– ses propres constantes, variables (appelées
"propriétés" ou "attributs")
– ses fonctions (appelées "méthodes")
• Méthodes habituelles :
– Constructeur / destructeur
– Accesseurs / modificateurs (getters / setters)

PHP objet 4
• Une définition de classe basique commence par le
mot-clé class, suivi du nom de la classe. Suit une paire
d'accolades contenant la définition des propriétés et
des méthodes appartenant à la classe.
– Exemple 1 : Définition typique d'une classe
<?php
class SimpleClass
{
// déclaration des propriétés
// déclaration des méthodes
}
?>

PHP objet 5
• La construction d’un objet à partir de la classe
génératrice s’appelle instanciation.
– Les objets sont des instances de la classe
– Pour créer une instance d'une classe, le mot-clé new
doit être utilisé. Un objet sera alors systématiquement
créé, à moins qu'il ait un constructeur défini qui lance
une exception en cas d'erreur.
– Exemple 2 : Création d’une instance
<?php
$instance = new SimpleClass();
?>

PHP objet 6
• La visibilité d'une propriété, d'une méthode ou
une constante (à partir de PHP 7.1.0) peut être
définie en préfixant sa déclaration avec un mot-
clé : public, protected, ou private.
– Les éléments déclarés comme publics sont accessibles
partout.
– L'accès aux éléments protégés est limité à la classe
elle-même, ainsi qu'aux classes qui en héritent et
parente.
– L'accès aux éléments privés est uniquement réservé à
la classe qui les a définis.
PHP objet 7
• L'héritage affecte la manière dont de
nombreuses classes sont en relation les unes
avec les autres.
– Lorsqu'une classe est étendue, la classe enfant
hérite de toutes les méthodes publiques et
protégées, propriétés et constantes de la classe
parente.
• Les méthodes privées d'une classe parente ne sont pas
accessibles à la classe enfant.

PHP objet 8
• Les méthodes magiques
– sont des méthodes prédéfinies dont le nom commence par
"__" et qui sont appelées automatiquement lors
d'opérations spécifiques sur les objets.
– Quelques méthodes magiques :
• __construct : appelée à l'instanciation
• __set : appelée lors de l'écriture de propriétés privées ou
protégées
• __get : appelée lors de la lecture de propriétés privées ou
protégées
• __isset : appelée lors de l'appel à isset() ou empty() sur des
propriétés privées ou protégées
• __unset : appelée lors de la destruction de propriétés privées ou
protégées

PHP objet 9
• Exemple 3 : Définition d’une classe
class MyClass Déclaration de classe
{
private string $myData; Attribut privé

public function __construct(string $param) { Constructeur

$this->myData = $param; public
}
public function __destruct() { Référence à l’instance courante
echo 'Destruction...’;
Destructeur public
}
public function show(): void { Méthode publique
echo 'my data : ' . $this->myData;
} Accès à un attribut
}

PHP objet 10
• Exemple 4 : Utilisation d’une classe
<?php
require 'myClass.php'; Inclusion de la définition de la classe

// Nouvel objet
$object = new MyClass(12); Création d'un objet
// Utilisation d'une méthode Méthode affiche de l'objet
$object->show(); $object
class error:
Fatal MyClassCannot
{ access private property
$object->myData = 'day';
private $myData;
MyClass::$myData L'attribut est privé
... function __destruct() {
Destruction...
echo 'Destruction...'; }
unset($object); Destruction de l'objet $object
?>

PHP objet 11
• Exemple 5 : Valeur par défaut des attributs
class MyClass
{
private string $myData = 'Défaut'; Attribut avec valeur par défaut

public function set(string $value): void

{ $this->myData = $value; }

public function show(): void

{ echo 'my data : '.$this->myData; } Nouvel objet
}
$o = new MyClass(); Affichage
$o->show(); my data : Défaut
$o->set('Nouvelle'); Affectation
$o->show(); my data : Nouvelle
Affichage

PHP objet 12
• Exemple 6 : L’héritage
class Simple { Classe simple
function show(): void {
echo 'Je suis Simple'; } Une méthode publique
}
Classe étendue héritant de la
class Extended extends Simple {
classe simple
function show(): void {
parent::show(); Surcharge de la méthode
echo ' mais aussi Extended';
} Appel de la méthode du parent
}
$s = new Simple();
$e = new Extended();
$s->show(); Je suis Simple
$e->show(); Je suis Simple mais aussi Extended

PHP objet 13
• Propriétés et méthodes statiques
– sont accédées en utilisant l' opérateur de
résolution de portée (::) et sans avoir besoin
d'instancier la classe
• Il est possible de référencer la classe en utilisant une
variable. La valeur de la variable peut être un mot-clé
(par exemple self, parent et static).
• la pseudo-variable $this n'est pas disponible dans les
méthodes déclarées comme statiques.

PHP objet 14
– Exemple 7 : Exemple avec une propriété statique
<?php
class Foo /*Accès à une propriété
{ statique*/
public static $my_static = 'foo'; echo Foo::$my_static;
foo
public function staticValue() { $foo = new Foo();
return self::$my_static;
} echo $foo->staticValue();
} foo
echo $foo->my_static;
class Bob extends Foo ?>
{
public function fooStatic() {
return parent::$my_static; Notice: Accessing static property
} Foo::$my_static as non static
} Warning: Undefined property:
Foo::$my_static

PHP objet 15
– Exemple 8 : Exemple avec une méthode statique
<?php
class Foo
{
public static function aStaticMethod() {
// ...
}
}
// Accès à la méthode aStaticMethod()
Foo::aStaticMethod();
?>

PHP objet 16
• Constante de classe
– Exemple 9 : Constante publique de
class MyClass {
classe
public const MY_CONSTANT = 'Valeur';
(visibilité depuis
PHP7.1)
public function show(): void
{
echo self::MY_CONSTANT; Accès à la constante de
} classe depuis la classe
}

$c = new MyClass();
$c->show(); Valeur
Accès à la constante de classe à
echo MyClass::MY_CONSTANT; Valeur
l'extérieur de la classe

PHP objet 17
• Abstraction de classe
– PHP a des classes et méthodes abstraites.
– Les classes définies comme abstraites ne peuvent pas être
instanciées, et toute classe contenant au moins une
méthode abstraite doit elle-aussi être abstraite.
– Les méthodes définies comme abstraites déclarent
simplement la signature de la méthode ; elles ne peuvent
définir son implémentation.
– Lors de l'héritage d'une classe abstraite, toutes les
méthodes marquées comme abstraites dans la déclaration
de la classe parente doivent être définies par la classe
enfant et suivre les règles habituelles d'héritage.

PHP objet 18
• Abstraction de classe
– Exemple 10 :
<?php class ConcreteC extends EssaiClass
abstract class EssaiClass
{
{
/* Force les classes filles à définir protected function getValue() {
return "ConcreteC";
cette méthode*/
abstract protected function getValue(); }
}
// méthode commune $c = new ConcreteC;
public function printOut() { $c->printOut(); ConcreteC
echo $this->getValue() . "\n"; ?>
}
}

PHP objet 19
• Méthodes et classes finales
– Le mot-clé "final" empêche les classes enfants de
redéfinir une méthode ou constante en préfixant
la définition avec final.
– Si la classe elle-même est définie comme finale,
elle ne pourra pas être étendue.
– Exemple 11 de classe finale:

PHP objet 20
• Méthode et classe finales
<?php
final class BaseClass {
public function test() {
echo "BaseClass::test() appelée\n";
}
/* Comme la classe est déjà finale, le mot clé final est
redondant*/
final public function moreTesting() {
echo "BaseClass::moreTesting() appelée\n";
}
}
?>

PHP objet 21
• Parcours d’objets
– Exemple 11 : Parcours d'objets simple
<?php $c = new MyClass();
class MyClass
{
public $var1 = 'valeur 1'; //1ère méthode de parcours
public $var2 = 'valeur 2'; foreach($c as $key => $value) {
public $var3 = 'valeur 3'; echo "$key => $value\n";
protected $protected1 = 'variable protégée';
private $private1 = 'variable privée'; } var1 => valeur 1
//2ème méthodevar2 => valeur 2
de parcours
function iterateVisible() { var3 => valeur 3
$c->iterateVisible();
echo "MyClass::iterateVisible:\n"; ?> MyClass::iterateVisible:
foreach ($this as $key => $value) {
echo "$key => $value\n"; var1 => valeur 1
} var2 => valeur 2
} var3 => valeur 3
} protected1 => variable protégée
private1 => variable privée
PHP objet 22
• PHP a une gestion des exceptions similaire à ce
qu'offrent les autres langages de programmation.
• Une exception peut être lancée ("throw") et
attrapée ("catch") dans PHP.
• Le code devra être entouré d'un bloc try pour
faciliter la saisie d'une exception potentielle.
– Chaque try doit avoir au moins un bloc catch ou finally
correspondant.
• Un bloc catch définit comment réagir à une exception qui a
été lancée.
• Le code à l'intérieur du bloc finally sera toujours exécuté
après les blocs try et catch.

PHP objet 23
• Exemple 12 : Lancer une exception
<?php
function inverse($x) {
if (!$x) {
throw new Exception('Division par zéro.');
}
return 1/$x;
}
try {
echo inverse(5) . "\n"; 0.2
echo inverse(0) . "\n"; Exception reçue : Division par zéro.
} catch (Exception $e) {
echo 'Exception reçue : ', $e->getMessage(), "\n";
}
// Continuer l’exécution
echo "Bonjour le monde !\n"; Bonjour le monde !
?>

PHP objet 24
1. Créer une classe personne. Elle doit avoir les
propriétés nom, prénom et email, ainsi
qu’un constructeur et un destructeur.
2. Une méthode getpersonne() doit retourner
les informations complètes de la personne.
3. Une méthode setemail() doit permettre de
modifier l’email de la personne.
4. Créer des objets personne, et appliquer
l’ensemble des méthodes.
PHP objet 25
5. Créer une classe etudiant dérivée de la classe
personne. Elle doit avoir les propriétés nom,
prénom, email et matricule, ainsi qu’un
constructeur et un destructeur.
6. Ajouter les méthodes getmatricule(),
setmatricule().
7. Ajouter les contrôles de validité dans le
constructeur.

PHP objet 26
• Cours Bases de PHP de Jérôme Cutrona https://iut-
info.univ-
reims.fr/users/cutrona/intranet/but/s2/index.html
• Manuel PHP par le PHP Documentation Group (Mehdi
Achour, Friedhelm Betz, Antony Dovgal, Nuno Lopes,
Hannes Magnusson, Georg Richter, Damien Seguy, Jakub
Vrana, Et bien d'autres)
https://www.php.net/manual/fr/index.php
• Tutoriels L'antisèche de Dév. Web - Bloc 1 de V. MARTIN
sous la licence CC BY-NC 4.0 Deed sur HELMO (Haute Ecole
Libre de Mosane)
https://dartagnan.cg.helmo.be/~p150107/tutoriels/cheats
heet.php

PHP objet 27