Quelle est la différence fondamentale entre les modèles de conception Factory et Abstract Factory? [fermé]

StackOverflow https://stackoverflow.com/questions/1001767

Question

Quelle est la différence fondamentale entre les modèles Factory et Abstract Factory?

Était-ce utile?

La solution

Avec le modèle Factory, vous créez des instances d'implémentations ( Apple , Banana , Cherry , etc.) d'une interface particulière - dire, IFruit .

Avec le modèle Abstract Factory, vous offrez à quiconque le moyen de créer sa propre usine. Cela permet à votre entrepôt d'être soit un IFruitFactory , soit un IJuiceFactory , sans que votre entrepôt ait besoin de connaître les fruits ou les jus.

Autres conseils

  

La source de ces informations provient de: http://java.dzone.com / news / intro-design-patterns-abstract

Méthode Fabrique abstraite / Usine

Les méthodes d'une fabrique abstraite sont implémentées en tant que méthodes d'usine. Le modèle d'usine abstrait et le modèle de méthode d'usine dissocient le système client des classes d'implémentation réelles via les types abstraits et les usines. La méthode Factory crée des objets par héritage, l’abstrait Factory créant des objets par composition.

Le motif de fabrique abstraite se compose des éléments AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct et Client.

Comment implémenter

Le motif abstrait d'usine peut être implémenté à l'aide du motif de méthode usine, du motif prototype ou du motif singleton. L'objet ConcreteFactory peut être implémenté en tant que Singleton, car une seule instance de l'objet ConcreteFactory est nécessaire.

Le modèle Factory Method est une version simplifiée du modèle Abstract Factory. Le modèle Factory Method est chargé de créer des produits appartenant à une famille, tandis que le modèle Abstract Factory traite plusieurs familles de produits.

La méthode Factory utilise des interfaces et des classes abstraites pour découpler le client de la classe du générateur et des produits résultants. Abstract Factory dispose d’un générateur qui contient plusieurs méthodes d’usinage, ainsi que d’interfaces permettant de dissocier le client du générateur et des produits.

Quand utiliser le modèle de méthode usine

Utilisez le modèle Méthode d'usine lorsqu'il est nécessaire de découpler un client d'un produit particulier utilisé. Utilisez la méthode d'usine pour décharger un client de la création et de la configuration des instances d'un produit.

Quand utiliser le motif abstrait d'usine

Utilisez le modèle Abstract Factory lorsque les clients doivent être découplés des classes de produits. Particulièrement utile pour la configuration et la modification du programme. Le modèle Abstract Factory peut également imposer des contraintes sur les classes à utiliser avec d'autres. La construction de nouvelles usines de béton peut nécessiter beaucoup de travail.

Exemples:

Exemple d'usine d'abstrait 1

Cette spécification pour les disques pour préparer différents types de pâtes dans un fabricant de pâtes, l’abstrait Factory et chaque disque spécifique est une Factory. toutes les usines (disques de fabrication de pâtes) héritent de leurs propriétés de l'usine abstraite. Chaque disque contient des informations sur la création des pâtes, contrairement au fabricant de pâtes.

Exemple d'usine abstraite 2:

L’équipement d’estampage correspond à l’usine abstraite, car c’est un interface pour les opérations qui créent des objets produits abstraits. Les matrices correspondent à l'usine de béton, car elles créent un produit en béton. Chaque catégorie de pièce (capot, porte, etc.) correspond au produit abstrait. Des pièces spécifiques (c’est-à-dire la porte côté conducteur pour 99 camry) correspondent à les produits en béton.

Exemple de méthode d'usine:

La société de jouets correspond au créateur, car elle peut utiliser la fabrique pour créer des objets de produit. La division de la société de jouets qui fabrique un type spécifique de jouet (cheval ou voiture) correspond au ConcreteCreator.

Modèle d'usine: L’usine fabrique des implémentations IProduct

Modèle de fabrique abstraite: Une usine-usine produit des IFactories, qui à leur tour produisent des produits IP:)

[Mettre à jour en fonction des commentaires]
Ce que j’ai écrit précédemment n’est pas correct selon Wikipedia au moins. Une fabrique abstraite est simplement une interface de fabrique. Avec celui-ci, vous pouvez changer vos usines au moment de l'exécution pour autoriser différentes usines dans différents contextes. Des exemples peuvent être différentes usines pour différents systèmes d’exploitation, fournisseurs SQL, pilotes de middleware, etc.

Le motif de la fabrique abstraite

  • Fournit une interface pour la création familles de personnes apparentées ou à charge objets sans spécifier leur classes concrètes.

  • Le motif de la fabrique abstraite est très semblable à la méthode d'usine modèle. Une différence entre le deux est que avec l'usine abstraite modèle, une classe délègue le responsabilité de l'objet instanciation vers un autre objet via composition alors que l'usine Modèle de méthode utilise l'héritage et repose sur une sous-classe pour gérer la instanciation d'objet souhaité.

  • En fait, l'objet délégué utilise fréquemment les méthodes d'usine pour effectuer l'instanciation!

Modèle d'usine

  • Les modèles d'usine sont des exemples de motifs de création

  • Les motifs de création abstraits du processus d'instanciation d'objet. Ils cacher la façon dont les objets sont créés et aider rendre le système global indépendant de la façon dont ses objets sont créés et composé.

  • Les modèles de création de classe se concentrent sur l'utilisation de l'héritage pour décider de la objet à instancier Méthode d'usine

  • Les modèles de création d'objet se concentrent la délégation de l'instanciation à un autre objet Fabrique abstraite

Référence: Factory contre Abstract Factory

Méthode d'usine: vous avez une usine qui crée des objets dérivés d'une classe de base particulière

Fabrique abstraite: vous avez une fabrique qui crée d'autres fabriques , lesquelles créent à leur tour des objets dérivés des classes de base. Vous faites cela parce que vous ne voulez souvent pas simplement créer un seul objet (comme avec la méthode Factory) - vous voulez plutôt créer une collection d'objets liés.

La fabrique abstraite est une interface permettant de créer des objets liés, mais la méthode de la fabrique est une méthode. La fabrique abstraite est mise en œuvre par la méthode de la fabrique.

entrer la description de l

Différence fondamentale:

Usine: crée des objets sans exposer la logique d'instanciation au client.

Méthode d'usine : définissez une interface pour la création d'un objet, mais laissez les sous-classes décider de la classe à instancier. La méthode Factory permet à une classe de différer l’instanciation en sous-classes

Abstract Factory : fournit une interface permettant de créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes.

Le modèle

AbstractFactory utilise la composition pour déléguer la création d'un objet à une autre classe, tandis que le modèle Factory Method utilise l'héritage et repose sur la classe dérivée ou la sous-classe pour créer un objet

D'après les oodesign :

Usine :

entrez la description de l

Exemple: StaticFactory 

 public class ShapeFactory {

   //use getShape method to get object of type shape 
   public static Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }     
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();

      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }
}

L'exemple FactoryMethod utilisant une usine non statique est disponible dans cet article:

Conception Modèles: méthode vs usine vs usine abstraite

Quand utiliser: le client a simplement besoin d'une classe et ne se soucie pas de l'implémentation concrète qu'il obtient.

Méthode Factory : classe digaram:

entrez la description de l

Quand utiliser: le client ne sait pas quelles classes concrètes il devra créer au moment de l'exécution, mais souhaite simplement obtenir une classe qui fera le travail.

Fabrique abstraite de dzone

entrez la description de l

Quand utiliser: lorsque votre système doit créer plusieurs familles de produits ou que vous souhaitez fournir une bibliothèque de produits sans exposer les détails de la mise en œuvre.

Les exemples de code source dans les articles ci-dessus sont très utiles pour comprendre les concepts clairement.

Question SE associée avec exemple de code:

modèle d'usine. Quand utiliser les méthodes d'usine?

Différences:

  1. Les classes Abstract Factory sont souvent implémentées avec les méthodes Factory, mais peuvent également être implémentées avec Prototype
  2. Les concepteurs commencent par utiliser la méthode d'usine (moins de complications, plus de possibilités de personnalisation, les sous-classes se multiplient) et évoluent vers d'autres modèles de création (plus souples, plus complexes) nécessitant davantage de flexibilité.
  3. Les méthodes d'usine sont généralement appelées dans les méthodes de modèles.

Autres articles utiles:

factory_method de sourcemaking

abstract_factory de sourcemaking

abstract-factory-design-pattern à partir de journaldev

Exemple / scénario pour Abstract Factory

Je vis dans un endroit où il pleut pendant la saison des pluies, il neige en hiver et il fait chaud et ensoleillé en été. J'ai besoin de différents types de vêtements pour me protéger des éléments. Pour ce faire, je vais au magasin près de chez moi et demande des vêtements / objets pour me protéger. Le commerçant me donne l'article approprié selon l'environnement et la profondeur de ma poche. Les articles qu'il me donne sont du même niveau de qualité et de prix. Comme il est conscient de mes principes, il est facile pour lui de le faire. Mais lorsqu'un homme riche de l'autre côté de la rue présente les mêmes exigences, il obtient un article de marque coûteux. Une chose remarquable est que tous les éléments qu'il me donne se complètent en termes de qualité, de qualité et de coût. On peut dire qu'ils vont ensemble. Il en va de même pour les objets que ce riche obtient.

En examinant le scénario ci-dessus, j’apprécie donc l’efficacité du commerçant. Je peux remplacer ce commerçant par un magasin de résumés. Les éléments que nous obtenons avec les éléments abstraits et moi et les riches en tant que clients potentiels. Tout ce dont nous avons besoin est le produit / article qui convient à nos besoins.

Je peux maintenant facilement me voir en train de penser à une boutique en ligne offrant un ensemble de services à ses nombreux clients. Chaque client appartient à l'un des trois groupes. Lorsqu'un utilisateur du groupe premium ouvre le site, il obtient une excellente interface utilisateur, un panneau d'annonces hautement personnalisé, davantage d'options dans les menus, etc. Ces mêmes fonctionnalités sont présentées aux utilisateurs Gold, mais les fonctionnalités du menu sont réduites, les annonces sont généralement pertinentes, et légèrement moins egronomic UI. Enfin, c’est mon genre d’utilisateur, un & # 8216; groupe libre & # 8217; utilisateur. Je suis juste assez servi pour que je ne sois pas offensé. L’interface utilisateur est un strict minimum, les publicités sont tellement éloignées de la réalité que je ne sais pas ce qu’il contient, enfin, le menu ne contient que la déconnexion.

Si je pouvais créer quelque chose comme ce site Web, je considérerais certainement Abstract Pattern Pattern.

Produits abstraits: volet de publicité, menus, peintre d'interface utilisateur.
Abstract Factory: expérience utilisateur Web Store
Concreate Factory: Expérience utilisateur Premium, Expérience utilisateur Gold, Expérience utilisateur générale.

Beaucoup de gens se sentiront peut-être surpris, mais cette question est incorrecte . Si vous entendez cette question lors d'une interview, vous devez aider l'intervieweur à comprendre où se trouve la confusion.

Commençons par le fait qu’il n’existe pas de motif concret appelé "Usine". Il existe un motif appelé "Usine abstraite" et un motif appelé "Méthode d'usine".

Alors, que fait "Usine"? signifie alors? l’un des éléments suivants (tous peuvent être considérés comme corrects, en fonction de la portée de la référence):

  • Certaines personnes l'utilisent comme alias (raccourci) pour " Abstract Factory " ;.
  • Certaines personnes l'utilisent comme alias (raccourci) pour la méthode d'usine .
  • Certaines personnes l'utilisent comme nom plus général pour tous les modèles d'usine / de création. Par exemple. les deux " Abstract Factory " et " Méthode d'usine " sont des usines.

Et, malheureusement , de nombreuses personnes utilisent le mot-clé "Usine". pour désigner un autre type d’usine, qui crée une usine ou des usines (ou leurs interfaces). Basé sur leur théorie:

  

Le produit implémente IProduct, créé par Factory, qui   implémente IFactory, créé par AbstractFactory.

Pour comprendre à quel point c'est idiot, poursuivons notre équation:

  

AbstractFactory implémente IAbstractFactory, qui est créé par ...   AbstractAbstractFactory ???

J'espère que vous voyez le point. Ne vous trompez pas et n'inventez pas de choses qui n'existent pas pour des raisons raisonnables.

-

P.S. : Factory pour les produits est AbstractFactory, et Factory pour les usines abstraites n'est qu'un autre exemple de AbstractFactory. 

//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{    
   public Dough createDough(); //Will return you family of Dough
   public Clam createClam();   //Will return you family of Clam
   public Sauce createSauce(); //Will return you family of Sauce
}

class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{

   @Override
   public Dough createDough(){
      //create the concrete dough instance that NY uses
      return doughInstance;
   }

   //override other methods
}

Les définitions du manuel sont déjà fournies par d'autres réponses. Je pensais aussi en donner un exemple.

C’est donc ici que PizzaIngredientsFactory est une fabrique abstraite , car elle fournit des méthodes pour créer une famille de produits connexes.

Notez que chaque méthode de la fabrique abstraite est une méthode Factory en soi. Like createDough () est en soi une méthode fabrique dont les implémentations concrètes seront fournies par des sous-classes telles que NYPizzaIngredientsFactory . Ainsi, chaque emplacement différent peut créer des exemples d'ingrédients concrets appartenant à leur emplacement.

Méthode d'usine

  

Fournit une instance d'implémentation concrète

Dans l'exemple:
 - createDough () - fournit une implémentation concrète pour la pâte. Donc, ceci est une méthode d'usine

Fabrique abstraite

  

Fournit une interface pour créer une famille d'objets associés

Dans l'exemple:
 - PizzaIngredientsFactory est une fabrique abstraite car elle permet de créer un ensemble d'objets liés tels que Pâte , Palourdes , Sauce . . Pour créer chaque famille d’objets, il fournit une méthode fabrique.

Exemple tiré de modèles de conception Head First

J'ai quelques points à contribuer avec la réponse de John comme suit:

Abstract Factory est une fabrique d’usines!

Avec la " Méthode d’usine " (car "Factory" est ambigu), vous créez des implémentations ( Lemon , Orange , etc.) d’une interface particulière - par exemple, IFruit . Cette usine pourrait être appelée CitricFruitFactory .

Mais maintenant, vous voulez créer un autre type de fruit que CitricFruitFactory ne peut pas créer. Peut-être que le code de CitricFruitFactory n’aurait aucun sens si vous créez un Strawberry (la fraise n’est pas un fruit citrique!).

Vous pouvez donc créer une nouvelle usine appelée RedFruitFactory qui produit Strawberry , Raspberry , etc.

Comme l'a dit John Feminella: "Avec le modèle Abstract Factory, vous créez les implémentations d'une interface Factory particulière - par exemple, IFruitFactory . Chacun sait comment créer différents types de fruits. "

Les implémentations de IFruitFactory sont CitricFruitFactory et RedFruitFactory !

Mes sources sont: StackOverflow , tutorialspoint.com , programmeurs.stackexchange.com et CodeProject.com .

La

méthode Factory (également appelée Factory ) est destinée au client découplé d'une implémentation Interface . Par exemple, nous avons une interface Shape avec deux implémentations Circle et Square . Nous avons défini une classe de fabrique avec une méthode de fabrique avec un paramètre de détermination tel que Type et une nouvelle implémentation associée de l'interface Shape .

Abstract Factory contient plusieurs méthodes d'usine ou une interface de fabrique selon plusieurs implémentations de fabrique. Pour l'exemple suivant, nous avons une interface Color avec deux implémentations Red et Jaune . Nous avons défini une interface ShapeColorFactory avec deux RedCircleFactory et YellowSquareFactory . Le code suivant explique ce concept: 

interface ShapeColorFactory
{
    public Shape getShape();
    public Color getColor();
}

class RedCircleFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Circle();
    }

    @Override
    public Color getColor() {
        return new Red();
    }
}
class YellowSquareFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Square();
    }

    @Override
    public Color getColor() {
        return new Yellow();
    }
}

Ici la différence entre FactoryMethod et AbstractFactory . Méthode Factory renvoie simplement une classe d’interface mais Abstract Factory renvoie fabrique d’usine . En d'autres termes, Abstract Factory renvoie différentes combinaisons d'une série d'interfaces.

J'espère que mon explication est utile.

La principale différence entre ces usines réside dans ce que vous voulez faire avec les usines et quand vous voulez l'utiliser.

Parfois, lorsque vous effectuez une opération IOC (inversion du contrôle, par exemple injection de constructeur), vous savez que vous pouvez créer des objets solides. Comme indiqué dans l'exemple ci-dessus concernant les fruits, si vous êtes prêt à créer des objets de fruits, vous pouvez utiliser un simple modèle d'usine .

Mais souvent, vous ne voulez pas créer d'objets solides, ils viendront plus tard dans le déroulement du programme. Mais la configuration vous indique le type d’usine que vous souhaitez utiliser au début, au lieu de créer des objets, vous pouvez transférer les fabriques dérivées d’une classe d’usine commune au constructeur dans IOC.

Donc, je pense que cela concerne également la durée de vie et la création de l'objet.

Les méthodes Factory et Abstract Factory conservent les clients découplés des types concrets. Les deux créent des objets, mais la méthode Factory utilise l'héritage, tandis que Abstract Factory utilise la composition.

La Méthode Factory est héritée dans des sous-classes pour créer les objets concrets (produits), tandis que Abstract Factory fournit une interface pour la création de la famille de produits liés. La sous-classe de ces interfaces comment créer des produits connexes.

Ensuite, ces sous-classes lorsqu’elles sont instanciées sont transmises aux classes de produits où elles sont utilisées en tant que type abstrait. Les produits associés dans une Abstract Factory sont souvent implémentés à l'aide de Méthode Factory .

Extension de la réponse John Feminella:

Apple , Banana , Cherry implémente FruitFactory et utilise une méthode appelée Créer qui est seul responsable de la création de Apple, Banana ou Cherry. Vous avez terminé, avec votre méthode Factory .

Vous voulez maintenant créer une salade spéciale à partir de vos fruits et voici votre usine abstraite . Abstract Factory sait comment créer votre salade spéciale à partir de pommes, bananes et cerises. 

public class Apple implements Fruit, FruitFactory {
    public Fruit Create() {
        // Apple creation logic goes here
    }
}

public class Banana implements Fruit, FruitFactory {
    public Fruit Create() {
        // Banana creation logic goes here
    }
}

public class Cherry implements Fruit, FruitFactory {
    public Fruit Create() {
        // Cherry creation logic goes here
    }
}

public class SpecialSalad implements Salad, SaladFactory {
    public static Salad Create(FruitFactory[] fruits) {
        // loop through the factory and create the fruits.
        // then you're ready to cut and slice your fruits 
        // to create your special salad.
    }
}

Par définition, nous pouvons faire glisser les différences de deux:

Factory: une interface est utilisée pour créer un objet, mais la sous-classe décide de la classe à instancier. La création d'objet est effectuée lorsque cela est nécessaire.

Abstract Factory: le motif Abstract Factory agit comme une super-usine qui crée d’autres usines. Dans le modèle Abstract Factory, une interface est chargée de créer un ensemble d’objets apparentés, ou d’objets dépendants, sans spécifier leurs classes concrètes.

Ainsi, dans les définitions ci-dessus, nous pouvons souligner une différence particulière. c'est-à-dire que le motif Factory est responsable de la création des objets et que Abstract Factory est responsable de la création d'un ensemble d'objets associés. évidemment à travers une interface.

Modèle d'usine: 

public interface IFactory{
  void VehicleType(string n);
 }

 public class Scooter : IFactory{
  public void VehicleType(string n){
   Console.WriteLine("Vehicle type: " + n);
  }
 }

 public class Bike : IFactory{
  public void VehicleType(string n) {
  Console.WriteLine("Vehicle type: " + n);
  }
 }

 public interface IVehicleFactory{
  IFactory GetVehicleType(string Vehicle);
 }

 public class ConcreteVehicleFactory : IVehicleFactory{
 public IFactory GetVehicleType(string Vehicle){
   switch (Vehicle){
    case "Scooter":
     return new Scooter();
    case "Bike":
     return new Bike();
    default:
    return new Scooter();
  }
 }

 class Program{
  static void Main(string[] args){
   IVehicleFactory factory = new ConcreteVehicleFactory();
   IFactory scooter = factory.GetVehicleType("Scooter");
   scooter.VehicleType("Scooter");

   IFactory bike = factory.GetVehicleType("Bike");
   bike.VehicleType("Bike");

   Console.ReadKey();
 }
}

Modèle de fabrique abstraite: 

interface IVehicleFactory{
 IBike GetBike();
 IScooter GetScooter();
}

class HondaFactory : IVehicleFactory{
     public IBike GetBike(){
            return new FZS();
     }
     public IScooter GetScooter(){
            return new FZscooter();
     }
 }
class HeroFactory: IVehicleFactory{
      public IBike GetBike(){
            return new Pulsur();
     }
      public IScooter GetScooter(){
            return new PulsurScooter();
     }
}

interface IBike
    {
        string Name();
    }
interface IScooter
    {
        string Name();
    }

class FZS:IBike{
   public string Name(){
     return "FZS";
   }
}
class Pulsur:IBike{
   public string Name(){
     return "Pulsur";
   }
}

class FZscooter:IScooter {
  public string Name(){
     return "FZscooter";
   }
}

class PulsurScooter:IScooter{
  public string Name(){
     return "PulsurScooter";
   }
}

enum MANUFACTURERS
{
    HONDA,
    HERO
}

class VehicleTypeCheck{
        IBike bike;
        IScooter scooter;
        IVehicleFactory factory;
        MANUFACTURERS manu;

        public VehicleTypeCheck(MANUFACTURERS m){
            manu = m;
        }

        public void CheckProducts()
        {
            switch (manu){
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
            }

      Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " +      factory.GetScooter().Name());
        }
  }

class Program
    {
        static void Main(string[] args)
        {
            VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
            chk.CheckProducts();

            chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
            chk.CheckProducts();

            Console.Read();
        }
    }

Vérifiez ici: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm il semble que la méthode Factory utilise une classe particulière (non abstraite) comme classe de base, tandis que Abstract Factory utilise une classe abstraite à cet effet. De même, si vous utilisez une interface au lieu d'une classe abstraite, le résultat sera une implémentation différente du motif Abstract Factory.

: D

Abstract Factory est un modèle permettant de créer différents types d’interfaces. Supposons que votre projet nécessite d'analyser différents types de fichiers .csv contenant des informations spécifiques à la quantité, au prix et aux articles. Certains contiennent par exemple des informations sur les fruits, puis sur les chocolats. Après l'analyse, vous devez mettre à jour ces informations dans la base de données correspondante. Une fabrique abstraite vous renvoie l’usine d’analyseur et de modificateur, puis cette usine d’analyseur peut vous renvoyer un objet analyseur Chocolate, un objet analyseur de fruits, etc.

Je pense que nous pouvons comprendre la différence entre ces deux applications en voyant un exemple de code Java8: 

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let's create one
        Something something = new Something() {};

        //Or ask someone (FACTORY pattern)
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;

        //Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
        OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;

        //Same thing, but you don't need to write you own interfaces
        Supplier<Something> supplierOfSomething = () -> null;
        Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
    }

}

Maintenant, la question est de savoir quel mode de création devez-vous utiliser et pourquoi: Premier moyen (pas de modèle, juste un constructeur ordinaire): créer par vous-même n’est pas une bonne idée, vous devez faire tout le travail et votre code client est lié à une implémentation particulière.

La deuxième manière (à l'aide du modèle Factory): vous offre l'avantage de pouvoir passer n'importe quel type d'implémentation, ce qui peut fournir un type différent de quelque chose en fonction d'une condition (peut-être un paramètre passé à la méthode creational).

La troisième façon (en utilisant le motif Abstract Factory): Cela vous donne plus de flexibilité. Vous pouvez trouver différents types de créateurs de quelque chose en fonction de certaines conditions (peut-être un paramètre passé).

Notez que vous pouvez toujours vous échapper avec le motif Factory en combinant deux conditions (ce qui augmente légèrement la complexité du code et le couplage). Je suppose que c'est pourquoi nous voyons rarement des cas d'utilisation réels du motif Abstract Factory .

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top