9 juin 2024
La Programmation Orientée Objet
1# Définition
La programmation orientée objet est une méthode de programmation informatique de plus en plus plébiscitée, que ce soit dans le développement logiciel ou la data science. Organisée autour des objets, ou données, la programmation orientée objet offre de nombreux avantages.
La programmation orientée objet ou POO est une nouvelle façon de développer, en effet, cela permet d’organiser son code de manière non-procédurale. La POO permet une interaction plus facile avec nos différents objets. Cette façon de développer est incluse dans la plupart des langages de programmation.
2# La POO
<?php
class MonObjet{
}
?>
Pour définir un objet en POO, il faut instancier un objet, pour cela, on utilise les « class». Regardons ça avec un exemple plus concret :
<?php
class Utilisateur
{
}
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<?php
$user = new Utilisateur();
?>
</body>
</html>
On a notre objet appelé « Utilisateur», pour créer une nouvelle instance de celle-ci, il faut utiliser le mot-clef « new ». Cela permet de créer un nouvel objet Utilisateur, si besoin, nous pourrions avec notre objet créer un utilisateur dans notre base de données.
Dans une classe, on peut ajouter des valeurs par défaut en instanciant un « constructeur » ainsi que des variables ouvertes.
<?php
class Utilisateur
{
private $nom;
private $prenom;
private $service;
public function __construct($nom, $prenom, $service)
{
$this->nom = $nom;
$this->prenom = $prenom;
$this->service = $service;
}
}
Détaillons rapidement le code :
class Utilisateur = L’objet.
private $nom; = Variable utilisable uniquement dans notre classe.
public function __construct() = Constructeur de notre objet pour lui définir des valeurs par défaut.
$this->nom = $nom; = Notre objet prendra la valeur de la variable compris dans le constructeur.
Le $this permet d’utiliser la class directement pour définir ou utiliser des fonctions et/ou variables disponibles dans la class.
Le constructeur permet simplement de définir des valeurs à notre objet, ce n’est pas obligatoire. Regardons un autre exemple :
<?php
class Utilisateur{
public $nom;
public $prenom;
public $service;
}
?>
public $nom; = Variable publique, elle peut être utilisée directement depuis l’objet.
Essayons ça :
<?php
class Utilisateur{
public $nom;
public $prenom;
public $service;
}
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<?php
$user = new Utilisateur();
$user->nom = "Arkunis";
$user->prenom = "Cours Du Dev";
$user->service = "Développement";
var_dump($user);
?>
</body>
</html>
Le var_dump sert à débugger nos différentes variables. Regardons le résultat de notre exemple :
<body> object(Utilisateur)#1 (3) {
["nom"]=> string(7) “Arkunis”
["prenom"]=> string(12) "Cours Du Dev"
["service"]=> string(14) "Développement"
} </body>
Pour récupérer une valeur en particulier, il faudra utiliser le symbole « -> » (variable d’instance).
var_dump($user->nom);
On aura en retour string(7) "Arkunis".
Pour récupérer ou modifier une valeur de notre objet, il est coutume d’utiliser les setter et getter.
<?php
class Utilisateur{
private $nom;
public $prenom;
public $service;
public function getNom(){
return $this->nom;
}
public function setNom($nom){
$this->nom = $nom;
}
}
?>
Détaillons ce morceau de code :
private $nom; = Variable uniquement disponible depuis ma class.
public function getNom(){} = On appellera cette fonction pour afficher ce que notre variable $nom aura.
return $this->nom; = Return permet d’afficher notre variable à l’appel de la fonction.
public function setNom($nom){}= On utilisera cette fonction pour définir une valeur à notre variable $nom en utilisant le paramètre $nom.
$this->nom = $nom; = La classe Utilisateur qui a comme variable privée $nom prendra la valeur de notre paramètre $nom.
<body>
<?php
$user = new Utilisateur();
$user->setNom("Arkunis");
$user->prenom = "Cours Du Dev";
$user->service = "Développement";
echo $user->getNom();
?>
</body>
Et on aura donc en retour Arkunis.
Revenons rapidement sur les types possibles de visibilité des propriétés. On va pouvoir définir trois niveaux de visibilité ou d’accessibilité différents pour nos propriétés, méthodes (fonctions) et constantes (depuis PHP 7.1.0) grâce aux mots-clefs public, private et protected.
Les propriétés, méthodes ou constantes définies avec le mot-clef public vont être accessibles partout, c’est-à-dire depuis l’intérieur ou l’extérieur de la classe.
Les propriétés, méthodes ou constantes définies avec le mot-clef private ne vont être accessibles que depuis l’intérieur de la classe qui les a définies.
Les propriétés, méthodes ou constantes définies avec le mot-clef protected ne vont être accessibles que depuis l’intérieur de la classe qui les a définies ainsi que depuis les classes qui en héritent ou la classe parente.
3# Les classes étendues
Il est possible de créer une nouvelle classe tout en a liant avec une autre pour hériter de ses fonctions ou variables qui ne sont pas privées (private).
<?php
class Utilisateur
{
public $nom;
public $prenom;
public $service;
}
class Professeur extends Utilisateur
{
}
?>
Ajoutons un exemple plus parlant :
<?php
class Utilisateur
{
public $nom;
public $prenom;
public $service;
}
class Professeur extends Utilisateur
{
public function hello()
{
return "Bonjour ".$this->nom;
}
}
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<?php
$user = new Utilisateur();
$user->nom = "Arkunis";
$user->prenom = "Cours Du Dev";
$user->service = "Développement";
$prof = new Professeur();
$prof->nom = "Professeur";
echo $prof->hello();
?>
</body>
</html>
Résultat : Bonjour Professeur
On instancie Professeur pour créer un nouvel objet, et on peut utiliser les variables publiques pour interagir depuis notre nouvelle classe. Nous pourrions même utiliser les fonctions :
<?php
class Utilisateur
{
public $nom;
public $prenom;
public $service;
public function getNom(){
return $this->nom;
}
}
class Professeur extends Utilisateur
{
public function hello()
{
return "Bonjour ".$this->nom;
}
}
?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<?php
$user = new Utilisateur();
$user->nom = "Arkunis";
$user->prenom = "Cours Du Dev";
$user->service = "Développement";
$prof = new Professeur();
$prof->nom = "Professeur";
echo $prof->getNom();
?>
</body>
</html>
Résultat : Professeur
On constate que l’extension de classe peut avoir un impact très fort sur la conception d’un projet. Mais il y a quelques problèmes liés à ça.
Le premier problème qui peut survenir est que certains développeurs peuvent par mégarde ou tout simplement par manque d’application surcharger (c’est-à-dire réécrire ou encore substituer) certaines méthodes ou propriétés de classes lorsqu’ils créent leurs modules et le faire d’une façon qui va amener des bugs et des problèmes de sécurité sur les boutiques en cas d’installation du module en question.
Finalement, notez que si vous créez une architecture en POO PHP et que vous laissez la possibilité à des développeurs externes de modifier ou d’étendre cette architecture, vous devrez toujours faire bien attention à proposer une rétrocompatibilité de votre code à chaque mise à jour importante.
4# Constante, un objet très peu utilisé et pourtant très puissant
La constante comme son nom lui indique est là pour avoir une valeur constante, c’est-à-dire immuable. Prenons un exemple d’utilisation avec une constante :
<?php
class Utilisateur
{
public $nom;
public $prenom;
public $service;
public function getNom(){
return $this->nom;
}
}
class Professeur extends Utilisateur
{
public CONST TAXE = 20;
public function achatFourniture($parametre)
{
return $parametre + self::TAXE;
}
}
?>
Pour déclarer une constante, il ne faut pas lui mettre le symbole "$" devant comme une variable. De plus pour appeler une constante, il faut utiliser : self ou parent (si elle est comprise dans une classe étendue).
<body>
<?php
$user = new Utilisateur();
$user->nom = "Arkunis";
$user->prenom = "Cours Du Dev";
$user->service = "Développement";
$prof = new Professeur();
$prof->nom = "Professeur";
echo $prof->achatFourniture(30);
?>
</body>
Dans notre exemple, le professeur donne la liste des fournitures scolaires, et on en a pour un total de 30€ ($prof->achatFourniture(30);), puis à cela, on ajoute une taxe que prend l’école pour avoir fournis le matériel qui est de 20€ (public CONST TAXE = 20;). Si on additionne le tout (return $parametre + self::TAXE;) on a bien notre résultat de 50€ au total.
Si nous avions mis la taxe dans Utilisateur, on aurait dû changer le self par parent.
NB : L'opérateur de résolution de portée (aussi appelé Paamayim Nekudotayim) ou, en termes plus simples, le symbole "double deux-points" (::), fournit un moyen d'accéder a une constante, une propriété statique, ou une méthode statique d'une classe ou de l'une de ses classes parentes.
5# Les classes abstraites
Une classe abstraite est une classe qui ne va pas pouvoir être instanciée directement, c’est-à-dire qu’on ne va pas pouvoir manipuler directement.
Une méthode abstraite est une méthode dont seule la signature (c’est-à-dire le nom et les paramètres) va pouvoir être déclarée, mais pour laquelle on ne va pas pouvoir déclarer d’implémentation (c’est-à-dire le code dans la fonction ou ce que fait la fonction).
<?php
class Utilisateur extends prix
{
public $nom;
public $prenom;
public $service;
public function getNom(){
return $this->nom;
}
public function setPrix($param){
return $param + parent::TAXE;
}
}
class Professeur extends Utilisateur
{
}
abstract class prix{
public CONST TAXE = 20;
abstract public function setPrix($param);
}
?>
Ici, on déclare une fonction sans rien dedans, tout le contenu de cette fonction sera mis dans notre classe Utilisateur puis utilisé par Professeur :
<?php
$user = new Utilisateur();
$user->nom = "Arkunis";
$user->prenom = "Cours Du Dev";
$user->service = "Développement";
$prof = new Professeur();
$prof->nom = "Professeur";
echo $prof->setPrix(30);
?>
6# Méthode magique
Sans vous en rendre compte, vous avez utilisé une fonction dites magique, en effet, vous avez utilisé le constructeur (__construct).
Voici la liste des méthodes magique :
__construct();
__destruct();
__call();
__callStatic();
__get();
__set();
__isset();
__unset();
__toString();
__clone();
__sleep();
__wakeup();
__invoke();
__set_state();
__debugInfo();
Pour en apprendre plus sur les méthodes magique, je vous invite à vous rendre sur la documentation officielle : https://www.php.net/
J’espère que vous avez appris des choses.
Mots clés:
php symfony poo
Cours Du Dev
Recevez les dernières formations disponibles en vous inscrivant à la newsletter
Créé par arkunis