Le patron Fabrique Abstraite (Abstract Factory) fournit une interface pour créer des familles d'objets aparentés ou dépendants sans spécifier leurs classes concrètes. Alors que le patron Méthode de Fabrique (Factory Method) se concentre sur une hiérarchie de produits, la Fabrique Abstraite gère plusieurs hiérarchies de produits.

Une strutcure de fabriques abstraites peut créer des objets qui appartiennent à différentes hiérarchies de produits, formant ainsi une "famille" de produits. Il est important de noter que ce patron est pertinent uniquement lorsqu'il y a une exigence de création de multiples séries d'objets qui sont liés ou interdépendants. Si la seule exigence est de gérer de nouvelles séries d'objets, et non de nouveaux types d'objets au sein de ces séries, alors ce patron est approprié. Il est moins efficace pour introduire de nouveaux types d'objets.

Ce patron est souvent utilisé conjointement avec le patron Méthode de Fabrique pour gérer les complexités liées à la création d'objets.

En résumé des patrons de création :

• Méthode de Fabrique : Gère les variations d'un seul type d'objet.
• Fabrique Abstraite : Gère les variations d'une série do'bjets interdépendants.
• Constructeur (Builder) : Gère les variations dans la construction d'objets complexes.

Exemple d'implémentation en C#

Cet exemple illustre la création de voitures avec différentes couleurs et comportements à l'aide de la Fabrique Abstraite.

Interface de la Fabrique Abstraite

/**
* AF_AbstractFactory: L'interface de la fabrique abstraite.
* Définit les méthodes pour créer des familles d'objets.
*/
public abstract class AF_AbstractFactory {
   // Méthode pour créer une couleur de voiture abstraite
   public abstract AF_CarColor CreateColor();
   // Méthode pour créer un type de voiture abstrait (représentant son comportement)
   public abstract AF_CarAction CreateCar();
}
   

Fabrique Concrète : Skoda

using UnityEngine; // Supposant que ceci est utilisé dans un contexte Unity

/**
* AF_SkodaFactory: Implémente l'interface AF_AbstractFactory pour créer des produits Skoda.
*/
public class AF_SkodaFactory : AF_AbstractFactory {

   // Crée une couleur spécifique pour les voitures Skoda (ex: noir)
   public override AF_CarColor CreateColor() {
       return new AF_BlackColor();
   }

   // Crée une instance de voiture Skoda
   public override AF_CarAction CreateCar() {
       return new AF_SkodaCar();
   }
}
   

Fabrique Concrète : Ferrari

using UnityEngine; // Supposant que ceci est utilisé dans un contexte Unity

/**
* AF_FerrariFactory: Implémente l'interface AF_AbstractFactory pour créer des produits Ferrari.
*/
public class AF_FerrariFactory : AF_AbstractFactory {

   // Crée une couleur spécifique pour les voitures Ferrari (ex: rouge)
   public override AF_CarColor CreateColor() {
       return new AF_RedColor();
   }

   // Crée une instance de voiture Ferrari
   public override AF_CarAction CreateCar() {
       return new AF_FerrariCar();
   }
}
   

Produit Abstrait : Comportement de Voiture

using UnityEngine; // Supposant que ceci est utilisé dans un contexte Unity

/**
* AF_CarAction: Classe abstraite représentant le comportement d'une voiture.
*/
public abstract class AF_CarAction {
   // Méthode abstraite pour démarrer la voiture, en tenant compte de sa couleur
   public abstract void StartEngine(AF_CarColor carColor);
   // Méthode abstraite pour faire rouler la voiture, en tenant compte de sa couleur
   public abstract void Drive(AF_CarColor carColor);
   // Méthode abstraite pour arrêter la voiture, en tenant compte de sa couleur
   public abstract void Stop(AF_CarColor carColor);
}
   

Produit Concret : Ferrari

using UnityEngine; // Supposant que ceci est utilisé dans un contexte Unity

/**
* AF_FerrariCar: Implémentation concrète du comportement de voiture pour Ferrari.
*/
public class AF_FerrariCar : AF_CarAction {

   public override void StartEngine(AF_CarColor carColor) {
       Debug.Log($"{carColor.Describe()} La Ferrari a démarré.");
   }

   public override void Drive(AF_CarColor carColor) {
       Debug.Log($"{carColor.Describe()} La Ferrari roule.");
   }

   public override void Stop(AF_CarColor carColor) {
       Debug.Log($"{carColor.Describe()} La Ferrari est arrêtée.");
   }
}
   

Produit Concret : Skoda

using UnityEngine; // Supposant que ceci est utilisé dans un contexte Unity

/**
* AF_SkodaCar: Implémentation concrète du comportement de voiture pour Skoda.
*/
public class AF_SkodaCar : AF_CarAction {

   public override void StartEngine(AF_CarColor carColor) {
       Debug.Log($"{carColor.Describe()} La Skoda a démarré.");
   }

   public override void Drive(AF_CarColor carColor) {
       Debug.Log($"{carColor.Describe()} La Skoda roule.");
   }

   public override void Stop(AF_CarColor carColor) {
       Debug.Log($"{carColor.Describe()} La Skoda est arrêtée.");
   }
}
   

Produit Abstrait : Couleur de Voiture

/**
* AF_CarColor: Classe abstraite définissant la description d'une couleur de voiture.
*/
public abstract class AF_CarColor {
   // Méthode abstraite pour obtenir la description de la couleur
   public abstract string Describe();
}
   

Produit Concret : Couleur Noire

/**
* AF_BlackColor: Implémentation concrète pour la couleur noire.
*/
public class AF_BlackColor : AF_CarColor {

   public override string Describe() {
       return "Noire";
   }
}
   

Produit Concret : Couleur Rouge

/**
* AF_RedColor: Implémentation concrète pour la couleur rouge.
*/
public class AF_RedColor : AF_CarColor {

   public override string Describe() {
       return "Rouge";
   }
}