Permet de faciliter et optimiser la conception d'objet dans une application.
Abstract Factory est un pattern qui aide à la création d'objet, le but est de regrouper les objets en famille sans avoir à connaitre les bases de ces objets.
Abstract Factory va permettre de déresponsabiliser la classe mère. Pour cela, nous utilisons une interface qui va contenir des signatures de méthodes.
Ici FabriqueVehicule est une interface qui contient deux signatures de méthodes créeAutomobile() et créeScooter().
La classe Scooter est une classe mère d'héritage, les classes filles ScooterElectricité et ScooterEssence utilisent extends Scooter pour étendre cette classe.
Dans le second schéma, version générique du pattern, les structures sont affichées de façon plus générique
FabriqueConcrète1 et FabriqueConcrète2 correspondraient à FabriqueVéhiculeElectricité et FabriqueVehiculeEssence.
ProduitAbstraitA correspond à scooter et ProduitAbstraitB à Automobile.
Création d'objets complexes sans avoir à s'occuper des problèmes d'implémentations
Ce pattern est utilisé pour séparer l'implémentation d'un cas spécifique de la logique/ du client.
Un client (utilisateur physique ou logiciel) a besoin de construire des objets complexes sans connaître son implémentation.
Construire des objets complexes ayant plusieurs implémentations.
Généraliser la construction
Builder pour préparer la création d'objet
Pour les patternes de type factory, on essaie de s'arranger pour que ce soit un singleton.
Notre application va utiliser la classe liasse vierge (LiasseVierge) qui ne possédera qu'une seule instance.
Pattern abstract factory est susceptible d'utiliser ce type d'instance.
Le pattern singleton est utilisé pour créer une instance unique d'une classe.
Dans certains cas c'est utile d'avoir une classe qui ne peut être définie que d'une seule instance.
Méthode de classe unique chargée de retourner cette instance.
Pattern qui fournit une méthode de classe pour retourner cette instance (méthode statique).
Chaque classe qui utilise la liasse vierge doit avoir accès à la même instance.
On doit surtout s'arranger pour qu'on ne puisse pas en créer de nouvelles (avec l'opérateur new)
Singleton est une instance globale
Exemple de singleton:
public class Vendeur
{
private static Vendeur _instance = null;
private Vendeur() {
}
public static Vendeur Instance()
{
if (_instance == null)
_instance = new Vendeur();
return _instance;
}
} static void Main(string[] args)
{
Vendeur vendeur1 = Vendeur.Instance();
Vendeur vendeur2 = Vendeur.Instance();
vendeur1.sales = 10;
if(vendeur2.sales == vendeur1.sales)
Console.WriteLine("Singleton fonctionnel");
else
Console.WriteLine("Singleton non fonctionnel");
}Permet de cloner des objets
Le pattern prototype permet la création d'objets à partir d'autres objets appelés "prototypes" disposant d'une méthode Clone() qui retourne un objet identique.
Exemple du design pattern Prototype:
public abstract class Document
{
protected string contenu = "";
public Document duplique()
{
Document resultat;
resultat = (Document)this.MemberwiseClone();
return resultat;
}
public void remplit(string informations)
{
contenu = informations;
}
public abstract void imprime();
public abstract void affiche();
}Lien vers Object.MemberWiseClone
Les patterns de structuration permettant de faciliter l'indépendance de l'interface d'un objet et de son implémentation.
En fournissant les interfaces ce pattern permet d'encapsuler la composition des objets.
Cela augmente le niveau d'abstraction d'un système donné un peu à la manière des patterns de création qui encapsulent la création d'objets.
Ces patterns mettent en avant les interfaces.
Exercice: Différence entre Composition et Héritage
Composition: C'est le fait d'avoir une instance d'une classe dans une autre classe
Héritage: Une classe fille hérite des propriétés et des méthodes de la classe parente
Source: Composition vs Héritage
Le but de ce pattern est de convertir l'interface d'une classe donnée en une interface attendue par des clients afin qu'ils puissent travailler ensemble.
En résumé, il permet de donner à une classe existante une nouvelle interface pour répondre aux besoins d'un client.
Composition: protected ComposantPdf outilPdf = new ComposantPdf();.
Adapter: Classe ComposantPdf car elle hérite de l'interface et permet d'appeler d'autres méthodes
Le pattern est utilisé pour séparer le comportement de l'implémentation de l'interface et de l'implémentation de l'objet.
On s'intéresse au demande d'immatriculation des véhicules.
Le formulaire de demande d'immatriculation possède deux implémentations différentes.
Classe abstraite mère: FormulaireImmat
Classe fille :
- FormulaireImmatHTML
- FormulaireImmatAPP
Au départ le système a été conçu pour la France uniquement.
Ensuite on a du créé en sous-classe FormulaireImmatCH elle aussi abstraite pour avoir également deux sous-classes concrètes (qui sont FormulaireImmatHTML et FormulaireImmatAPP dédiées à la Suisse)
ABSTRACTION --> abstract class
IMPLEMENTATION --> interface
L'abstract class appelle l'interface
Composite est un patron de conception structurel qui permet d’agencer les objets dans des arborescences afin de pouvoir traiter celles-ci comme des objets individuels.
C'est comme une profondeur d'arbre
Ce pattern offre un cadre de conception d'une composition d'objets dont on ne connaît pas la profondeur. (On peut utiliser un arbre en tant qu'analogie)
Les "clients" interagissent avec les objets sans connaitre la structure de l'arbre.
Ce pattern permet d'ajouter DYNAMIQUEMENT des fonctionnalités SUPPLEMENTAIRES à un objet sans modifier l'interface de l'objet ("les clients de l'objet ne sont pas au courant de la modification")
Il s'agit d'une alternative à la création d'une sous-classe qui permettrait d'enrichir l'objet.
Les pattern de comportement permettent de distribuer des traitements/ des algorithmes entre les objets.
Ils organisent les interactions en renseignant le "flux de controle" et de traitement au sein d'un système d'objets.
La distribution se fait soit par héritage soit par "délégation"
Le but est de construire une chaine d'objets de manière à ce que si un objet de la chaine ne peut répondre à une enquête, il puisse la passer à un "successeur" et ainsi de suite jusqu'à ce que l'un des objets puissent y répondre.
Ce pattern transforme une requête en objet
Ceci facilite les opérations relatives à la requête ex: Annulation, queue, suivi, etc...
