Concept de programmation orientée objet (POO) en PHP avec exemple

Qu’est-ce que les POO ?

La programmation orientée objet est une approche du développement logiciel qui modélise une application à partir d'objets du monde réel, tels que des employés, des voitures et des comptes bancaires. Une classe définit les propriétés et les méthodes d'un objet du monde réel. Un objet est une instance d'une classe.

Les trois composantes fondamentales de l'orientation objet sont :

• Analyse orientée objet – fonctionnalité du système
• Conception orientée objet – architecture du système
• Programmation orientée objet – mise en œuvre de l'application

Principes de programmation orientée objet

Les trois grands principes de la POO sont :

• Encapsulation – Il s’agit de masquer les détails d’implémentation et de n’exposer que les méthodes. Les principaux objectifs de l’encapsulation sont les suivants :
  • Réduisez la complexité du développement logiciel – en masquant les détails d’implémentation et en exposant uniquement les opérations, l’utilisation d’une classe devient facile.
  • Protégez l'état interne d'un objet : l'accès aux variables de classe se fait via des méthodes telles que get et set. Cela rend la classe flexible et facile à maintenir.
  • Autoriser la modification de l'implémentation interne de la classe sans craindre de casser le code qui utilise cette classe.
• Droit des successions – Ceci concerne la relation entre les classes. Cette relation prend la forme d'une relation parent-enfant. L'enfant utilise les méthodes définies dans la classe parent. L'objectif principal de l'héritage est :
  • Réutilisabilité – plusieurs classes enfants peuvent hériter d'une même classe parente. Ceci est très utile lorsqu'il faut fournir des fonctionnalités communes telles que l'ajout, la mise à jour et la suppression de données dans la base de données.
• Polymorphisme – Il s’agit d’avoir une interface unique avec de nombreuses implémentations différentes. Le but principal du polymorphisme est :
  • Pour simplifier la maintenance des applications et les rendre plus extensibles.

Oops Concepts en PHP

PHP est un langage de script orienté objet ; il prend en charge tous les principes ci-dessus. Ces principes sont mis en œuvre grâce à :

• Encapsulation – via l’utilisation des méthodes « get » et « set », et des modificateurs d’accès.
• Droit des successions – via l'utilisation du mot-clé extends
• Polymorphisme – via l'utilisation du mot-clé implements

Maintenant que nous avons les connaissances de base de la POO et de la façon dont elle est prise en charge dans PHPExaminons maintenant des exemples qui mettent en œuvre les principes ci-dessus.

Qu'est-ce qu'UML ?

Le langage de modélisation unifié (UML) est une technique utilisée pour concevoir et documenter les systèmes orientés objet.

UML produit de nombreux documents, mais nous allons nous intéresser au diagramme de classes, qui est très important pour la programmation PHP orientée objet.

Exemple de diagramme de classes

Clé du diagramme de classes

• Le boîte supérieure contient le nom de la classe
• Le boîte du milieu contient les variables de classe
• Le boîte inférieure contient les méthodes de classe
• Le moins (-) signe signifie portée privée
• Le plus (+) signe signifie portée publique
• Le hachage (#) signe signifie portée protégée

Comment créer une classe en PHP

Le mot-clé class est utilisé pour définir une classe en PHP. Vous trouverez ci-dessous les règles de création d'une classe en PHP.

• Le nom de la classe doit commencer par une lettre
• Le nom de la classe ne peut pas être un mot réservé PHP
• Le nom de la classe ne peut pas contenir d'espaces

Supposons que nous voulions créer une classe pour représenter les animaux. Nous commencerons par identifier les caractéristiques communes à tous les animaux.

• Tous les animaux appartiennent à une famille, comme les herbivores, les carnivores, etc.
• Tous les animaux mangent de la nourriture

Le diagramme ci-dessous représente le diagramme de classes de l'animal.

Passons maintenant au codage de notre classe Animal.

<?php
class Animal
{
    private $family;
    private $food;
    public function __construct($family, $food)
    {
        $this->family = $family;
        $this->food = $food;
    }
    public function get_family()
    {
        return $this->family;
    }
    public function set_family($family)
    {
        $this->family = $family;
    }
    public function get_food()
    {
        return $this->food;
    }
    public function set_food($food)
    {
        $this->food = $food;
    }
}
?>

ICI,

• « private $family, $food » signifie que les variables ne sont pas accessibles directement en dehors de la classe (encapsulation).
• La fonction `public function __construct($family…)` est la méthode constructeur de PHP. Elle est appelée à chaque création d'une instance de la classe. Dans ce cas, nous définissons la famille et la nourriture.
• « public function get…() » est la méthode utilisée pour accéder à la valeur de la famille ou de l'aliment (encapsulation).
• « public function set…() » est la méthode utilisée pour définir la valeur de la famille ou de l'aliment (encapsulation).

Comment implémenter l'héritage en PHP

Nous travaillerons avec une vache et un lion. La vache et le lion héritent de la classe Animal.

Le diagramme de classes ci-dessous montre les relations.

Notez que la vache hérite de la classe Animal et définit également ses propres variables et méthodes.

Passons maintenant au codage de la classe Cow.

<?php
class Cow extends Animal
{
    private $owner;
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
    public function set_owner($owner)
    {
        $this->owner = $owner;
    }
    public function get_owner()
    {
        return $this->owner;
    }
}
?>

Passons maintenant au codage de la classe Lion.

<?php
class Lion extends Animal
{
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
}
?>

ICI,

• « class … extends Animal » fait en sorte que les classes Cow et Lion utilisent les méthodes de la classe Animal (héritage).

Comment créer un objet de la classe

Les classes Animal, Cow et Lion doivent toutes se trouver dans le même répertoire par souci de simplicité.

Créons maintenant l'application qui utilise nos classes.

Exemple de classe PHP

<?php
require 'Animal.php';
require 'Cow.php';
require 'Lion.php';
$cow = new Cow('Herbivore', 'Grass');
$lion = new Lion('Carnivore', 'Meat');
echo '<b>Cow Object</b> <br>';
echo 'The Cow belongs to the ' . $cow->get_family() . ' family and eats ' . $cow->get_food() . '<br><br>';
echo '<b>Lion Object</b> <br>';
echo 'The Lion belongs to the ' . $lion->get_family() . ' family and eats ' . $lion->get_food();
?>

Tester notre application

Voyons maintenant notre application dans un navigateur web.

Les deux objets réutilisent les méthodes get_family et get_food héritées de la classe Animal, ce qui illustre le principe d'héritage en action.

Comment implémenter le polymorphisme en PHP

Supposons que nous souhaitions développer une application qui se connecte à différents moteurs de bases de données tels que : MySQL et SQL Le serveur utilise la même interface uniforme. Nous pouvons créer une interface qui définit les méthodes standard et une valeur absolue.tracclasse t qui implémente les méthodes communes.

• Interface – c’est semblable à une classe. Il définit uniquement les méthodes et les paramètres.
• Abdostracclasse T – c’est une classe qui ne peut pas être utilisée pour créer directement un objet. Son objectif est de fournir des implémentations partielles ou totales de méthodes courantes.

Le diagramme de classes ci-dessous illustre la relation entre nos abstracclasses t, interfaces et classes d'implémentation.

Commençons par créer nos abdominaux.tracclasse t.

<?php
abstract class DBCommonMethods
{
    private $host;
    private $db;
    private $uid;
    private $password;
    public function __construct($host, $db, $uid, $password)
    {
        $this->host = $host;
        $this->db = $db;
        $this->uid = $uid;
        $this->password = $password;
    }
}
?>

ICI,

• « abdos »trac« classe t » signifie que la classe ne peut pas être utilisée directement pour créer un objet
• « $host, $db… » sont des variables de classe communes à toutes les implémentations.
• « function __construct(…) » est la méthode constructeur de la classe qui définit les valeurs des variables communes lors de l'initialisation.

Créons maintenant l'interface qui contient les méthodes standard, dont l'implémentation variera selon le moteur de base de données.

<?php
interface DBInterface
{
    public function db_connect();
    public function insert($data);
    public function read($where);
    public function update($where);
    public function delete($where);
}
?>

ICI,

• « interface » est le mot-clé pour créer des interfaces
• « fonction publique…(…) » sont les méthodes standards à mettre en œuvre

Créons maintenant les classes concrètes qui étendront la classe DBCommonMethods et implémenteront l'interface DBInterface. Tout d'abord, MySQLDriver.php :

<?php
class MySQLDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

Ensuite, MSSQLServerDriver.php :

<?php
class MSSQLServerDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

ICI,

• « class … extends DBCommonMethods » utilise les méthodes de DBCommonMethods
• « … implémente DBInterface » garantit que la classe fournit les méthodes standard quel que soit le pilote de base de données utilisé.

Le code utilisant les classes ci-dessus ressemblerait à ceci :

<?php $db = new MySQLDriver($host, $db, $uid, $password); ?>

Ou:

<?php $db = new MSSQLServerDriver($host, $db, $uid, $password); ?>

Le reste du code serait identique pour les deux pilotes, par exemple :

<?php
$db->db_connect();
$db->insert($data);
?>

Voici le polymorphisme en action : les mêmes appels de méthode fonctionnent sur n’importe quel pilote qui implémente l’interface, de sorte que le code environnant ne change jamais lorsque vous changez de moteur de base de données.

FAQ