Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Design Patterns en Java
  3. Le pattern Abstract Factory
Extrait - Design Patterns en Java Descriptions et solutions illustrées en UML 2 et Java (5e édition) - Les 23 modèles de conception
Extraits du livre
Design Patterns en Java Descriptions et solutions illustrées en UML 2 et Java (5e édition) - Les 23 modèles de conception Revenir à la page d'achat du livre

Le pattern Abstract Factory

Description

Le but du pattern Abstract Factory est la création d’objets regroupés en familles sans devoir connaître les classes concrètes destinées à la création de ces objets.

Exemple

Le système de vente de véhicules gère des véhicules fonctionnant à l’essence et des véhicules fonctionnant à l’électricité. Cette gestion est confiée à l’objet Catalogue qui crée de tels objets.

Pour chaque produit, nous disposons d’une classe abstraite, d’une sous-classe concrète décrivant la version du produit fonctionnant à l’essence et d’une sous-classe décrivant la version du produit fonctionnant à l’électricité. Par exemple, à la figure 2-2.1, pour l’objet scooter, il existe une classe abstraite Scooter et deux sous-classes concrètes ScooterÉlectricité et ScooterEssence.

L’objet Catalogue peut utiliser ces sous-classes concrètes pour instancier les produits. Cependant si, par la suite, de nouvelles familles de véhicules doivent être prises en compte par la suite (diesel ou mixte essence-électricité), les modifications à apporter à l’objet Catalogue peuvent être assez lourdes.

Le pattern Abstract Factory résout ce problème en introduisant une interface FabriqueVéhicule qui contient la signature des méthodes pour définir chaque produit. Le type de retour de ces méthodes est constitué par l’une des classes abstraites...

Structure

1. Diagramme de classes

La figure 2-2.2 détaille la structure générique du pattern.

images/figure32.PNG

Figure 2-2.2 - Structure du pattern Abstract Factory

2. Participants

Les participants au pattern sont les suivants :

  • FabriqueAbstraite (FabriqueVéhicule) est une interface spécifiant les signatures des méthodes créant les différents produits.

  • FabriqueConcrète1, FabriqueConcrète2 (FabriqueVéhicule- Électricité, FabriqueVéhiculeEssence) sont les classes concrètes implantant les méthodes créant les produits pour chaque famille de produits. Connaissant la famille et le produit, elles sont capables de créer une instance du produit pour cette famille.

  • ProduitAbstraitAet ProduitAbstraitB (Scooter et Automobile) sont les classes abstraites des produits indépendamment de leur famille. Les familles sont introduites dans leurs sous-classes concrètes.

  • Clientest la classe qui utilise l’interface de FabriqueAbstraite.

3. Collaborations

La classe Client utilise une instance de l’une des fabriques concrètes pour créer ses produits au travers de l’interface de FabriqueAbstraite.

Normalement, il ne faut créer qu’une seule instance des fabriques concrètes, celle-ci pouvant être partagée par plusieurs clients.

Domaines d’utilisation

Le pattern est utilisé dans les domaines suivants :

  • Un système utilisant des produits a besoin d’être indépendant de la façon dont ces produits sont créés et regroupés.

  • Un système est paramétré par plusieurs familles de produits qui peuvent évoluer.

Exemple en Java

Nous introduisons maintenant un petit exemple d’utilisation du pattern écrit en Java. Le code Java correspondant à la classe abstraite Automobile et ses sous-classes est donné à la suite. Il est très simple, décrit les quatre attributs des automobiles ainsi que la méthode afficheCaracteristiques qui permet de les afficher.

public abstract class Automobile 
{ 
  protected String modele; 
  protected String couleur; 
  protected int puissance; 
  protected double espace; 
 
  public Automobile(String modele, String couleur, int 
    puissance, double espace) 
  { 
    this.modele = modele; 
    this.couleur = couleur; 
    this.puissance = puissance; 
    this.espace = espace; 
  } 
 
  public abstract void afficheCaracteristiques(); 
} 
 
public class AutomobileElectricite extends Automobile 
{ 
  public AutomobileElectricite(String modele, String 
    couleur, int puissance, double espace) 
  { 
    super(modele, couleur, puissance, espace); 
  } 
 
  public void afficheCaracteristiques() 
  { 
    System.out.println( 
      "Automobile électrique de modele : " + modele +  
      " de couleur : " + couleur + " de puissance : " + 
      puissance + " d'espace : " + espace); 
  } 
} 
 
public class AutomobileEssence extends Automobile 
{ 
  public AutomobileEssence(String modele, String couleur, 
    int puissance, double espace) 
  { 
    super(modele...