1.

Modèle de création :

a) Fabrique de création (Factory) :

<?php

interface Produit {

public function utiliser();

class ProduitA implements Produit {

public function utiliser() {

echo "Utilisation du produit A\n";

class ProduitB implements Produit {

public function utiliser() {

echo "Utilisation du produit B\n";

class FabriqueProduit {

public static function creerProduit($type) {

switch ($type) {

case 'A':

return new ProduitA();

case 'B':

return new ProduitB();

default:

throw new Exception("Type de produit inconnu");

}
// Utilisation de la fabrique pour créer des produits

$produitA = FabriqueProduit::creerProduit('A');

$produitA->utiliser(); // Output: Utilisation du produit A

$produitB = FabriqueProduit::creerProduit('B');

$produitB->utiliser(); // Output: Utilisation du produit B

?>

Explication : Le modèle de fabrique de création (Factory) permet de déléguer la création d'objets à

une fabrique plutôt que de les instancier directement. Cela permet de centraliser la logique de
création et de rendre le code plus flexible en cas de modification ou d'ajout de nouveaux types de
produits.

b) Singleton :

<?php

class Singleton {

private static $instance;

private function __construct() {

// Empêche l'instanciation directe de la classe

public static function getInstance() {

if (self::$instance === null) {

self::$instance = new self();

return self::$instance;

public function someBusinessLogic() {

// Logique métier du singleton

}
// Utilisation du singleton

$singleton = Singleton::getInstance();

$singleton->someBusinessLogic();

?>

Explication : Le modèle Singleton permet de garantir qu'une classe ne possède qu'une seule instance
dans toute l'application. Cela peut être utile lorsque vous avez besoin d'une unique ressource
partagée, telle qu'une connexion à une base de données ou un fichier de configuration. La méthode
getInstance() est utilisée pour récupérer l'instance unique de la classe.

2. Modèle des Structure :

a. Adapter :

<?php

interface Notification {

public function send($message);

class EmailNotification implements Notification {

public function send($message) {

echo "Envoi d'un e-mail : $message\n";

class SMSNotification {

public function push($message) {

echo "Envoi d'un SMS : $message\n";

class SMSAdapter implements Notification {

private $smsNotification;

public function __construct(SMSNotification $smsNotification) {

$this->smsNotification = $smsNotification;

}
 public function send($message) {

$this->smsNotification->push($message);

// Utilisation de l'adaptateur pour envoyer des notifications

$emailNotification = new EmailNotification();

$emailNotification->send("Bonjour!");

$smsNotification = new SMSNotification();

$smsAdapter = new SMSAdapter($smsNotification);

$smsAdapter->send("Salut!");

?>

Explication : Le modèle Adapter permet de faire collaborer des classes qui ne pourraient pas le faire
autrement en convertissant l'interface d'une classe en une autre interface attendue par le client.
Dans l'exemple ci-dessus, la classe SMSAdapter permet d'utiliser un objet SMSNotification en tant
qu'implémentation de l'interface Notification, de sorte qu'il puisse être utilisé de la même manière
que l'objet EmailNotification.

b. Proxy :

<?php

interface Sujet {

public function action();

class SujetConcret implements Sujet {

public function action() {

echo "Action du sujet concret\n";

class Proxy implements Sujet {

private $sujet;
 public function __construct(Sujet $sujet) {

$this->sujet = $sujet;

public function action() {

// Avant l'exécution de l'action du sujet concret

echo "Avant l'action\n";

// Exécution de l'action du sujet concret

$this->sujet->action();

// Après l'exécution de l'action du sujet concret

echo "Après l'action\n";

// Utilisation du proxy pour exécuter une action sur le sujet concret

$sujetConcret = new SujetConcret();

$proxy = new Proxy($sujetConcret);

$proxy->action();

?>

Explication : Le modèle Proxy permet de contrôler l'accès à un objet en fournissant une interface
similaire. Dans l'exemple ci-dessus, le proxy Proxy enveloppe un objet SujetConcret et ajoute un
comportement supplémentaire avant et après l'exécution de l'action du sujet concret. Cela permet
d'effectuer des tâches supplémentaires, telles que la vérification des autorisations, la mise en cache
ou la journalisation, sans modifier directement l'objet d'origine.