Qual è la differenza di base tra i modelli Factory e Abstract Factory?

Con il modello di fabbrica, si producono casi di implementazioni ( Apple, Banana, Cherry, etc.) di una particolare interfaccia - per esempio, IFruit.

Con il modello Abstract Factory, offri a chiunque la possibilità di fornire la propria fabbrica. Ciò consente al tuo magazzino di essere unoIFruitFactory o un IJuiceFactory, senza richiedere al tuo magazzino di sapere nulla di frutta o succhi di frutta.

Fonte per queste informazioni tratte da: http://java.dzone.com/news/intro-design-patterns-abstract

Fabbrica astratta vs. metodo di fabbrica

I metodi di una fabbrica astratta sono implementati come metodi di fabbrica. Sia il modello astratto di fabbrica che il modello del metodo di fabbrica separano il sistema client dalle classi di implementazione effettive attraverso i tipi e le fabbriche astratte. Il metodo Factory crea oggetti tramite ereditarietà in cui Abstract Factory crea oggetti attraverso la composizione.

Il modello astratto di fabbrica è composto da un AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct e Client.

Come implementare

Il modello di fabbrica astratto può essere implementato utilizzando il modello di metodo di fabbrica, il modello prototipo o il modello Singleton. L'oggetto ConcreteFactory può essere implementato come Singleton poiché è necessaria solo un'istanza dell'oggetto ConcreteFactory.

Il modello Metodo di fabbrica è una versione semplificata del modello di Fabbrica astratta. Il modello Factory Method è responsabile della creazione di prodotti appartenenti a una sola famiglia, mentre il modello Abstract Factory si occupa di più famiglie di prodotti.

Il metodo Factory utilizza interfacce e classi astratte per disaccoppiare il client dalla classe del generatore e dai prodotti risultanti. Abstract Factory ha un generatore che è un contenitore per diversi metodi di fabbrica, insieme a interfacce che disaccoppiano il client dal generatore e dai prodotti.

Quando utilizzare il modello del metodo di fabbrica

Utilizzare il modello Metodo di fabbrica quando è necessario separare un client da un particolare prodotto che utilizza. Utilizzare il metodo Factory per sollevare la responsabilità di un cliente dalla creazione e configurazione delle istanze di un prodotto.

Quando utilizzare il modello astratto di fabbrica

Utilizzare il modello di Fabbrica astratta quando i clienti devono essere disaccoppiati dalle classi di prodotti. Utile soprattutto per la configurazione e la modifica del programma. Il modello di Fabbrica astratta può anche imporre vincoli su quali classi devono essere usate con gli altri. Potrebbe essere molto difficile realizzare nuove fabbriche concrete.

Esempi:

Esempio astratto di fabbrica 1

Questa specifica per i dischi di preparare diversi tipi di pasta in un produttore di pasta è la Fabbrica astratta, e ogni disco specifico è una Fabbrica. tutte le fabbriche (dischi per pastai) ereditano le loro proprietà dalla Fabbrica astratta. Ogni singolo disco contiene le informazioni su come creare la pasta, e il produttore della pasta no.

Esempio astratto di fabbrica 2:

L'apparecchiatura di stampaggio corrisponde alla Fabbrica astratta, in quanto è un'interfaccia per le operazioni che creano oggetti di prodotto astratti. Gli stampi corrispondono alla fabbrica di cemento, in quanto creano un prodotto concreto. Ogni categoria di parti (Cappuccio, Porta, ecc.) Corrisponde al prodotto astratto. Parti specifiche (ad es. Porta lato conducente per 99 camry) corrispondono ai prodotti in calcestruzzo.

Esempio di metodo di fabbrica:

La compagnia di giocattoli corrisponde al Creatore, poiché può utilizzare la fabbrica per creare oggetti prodotto. La divisione della società di giocattoli che produce un tipo specifico di giocattolo (cavallo o macchina) corrisponde al ConcreteCreator.

Modello di fabbrica: la fabbrica produce implementazioni di prodotti IP

Modello astratto di fabbrica: una fabbrica-fabbrica produce IFactories, che a sua volta produce prodotti IP :)

[Aggiornamento secondo i commenti]
Quello che ho scritto prima non è corretto almeno secondo Wikipedia . Una fabbrica astratta è semplicemente un'interfaccia di fabbrica. Con esso, puoi cambiare le tue fabbriche in fase di esecuzione, per consentire fabbriche diverse in contesti diversi. Esempi potrebbero essere fabbriche diverse per diversi sistemi operativi, provider SQL, driver middleware ecc.

Il modello astratto di fabbrica

• Fornire un'interfaccia per la creazione di famiglie di oggetti correlati o dipendenti senza specificare le loro classi concrete.

• Il modello Fabbrica astratta è molto simile al modello Metodo di fabbrica. Una differenza tra i due è che con il modello Fabbrica astratta, una classe delega la responsabilità dell'istanza dell'oggetto a un altro oggetto tramite la composizione, mentre il modello Metodo di fabbrica utilizza l'ereditarietà e si basa su una sottoclasse per gestire l'istanza dell'oggetto desiderata.

• In realtà, l'oggetto delegato utilizza frequentemente metodi di fabbrica per eseguire l'istanza!

Modello di fabbrica

• I modelli di fabbrica sono esempi di modelli di creazione

• I modelli creazionali astraggono il processo di istanziazione dell'oggetto. Nascondono il modo in cui gli oggetti vengono creati e aiutano a rendere il sistema globale indipendente dal modo in cui i suoi oggetti vengono creati e composti.

• I modelli di creazione di classi si concentrano sull'uso dell'ereditarietà per decidere l'oggetto da istanziare Metodo di fabbrica

• I modelli di creazione dell'oggetto si concentrano sulla delega dell'istanza a un altro oggetto Fabbrica astratta

Riferimento: Factory vs Abstract Factory

Metodo di fabbrica: hai una factory che crea oggetti che derivano da una particolare classe base

Fabbrica astratta: hai una fabbrica che crea altre fabbriche e queste fabbriche a loro volta creano oggetti derivati ​​da classi base. Lo fai perché spesso non vuoi solo creare un singolo oggetto (come con il metodo Factory), ma vuoi creare una raccolta di oggetti correlati.

Abstract factory è un'interfaccia per la creazione di oggetti correlati ma il metodo factory è un metodo. La fabbrica astratta è implementata con il metodo factory.

Differenza di base:

Factory: crea oggetti senza esporre la logica di istanza al client.

Metodo di fabbrica : definire un'interfaccia per la creazione di un oggetto, ma lasciare che le sottoclassi decidano quale classe creare un'istanza. Il metodo Factory consente a una classe di rinviare l'istanza alle sottoclassi

Fabbrica astratta : fornisce un'interfaccia per la creazione di famiglie di oggetti correlati o dipendenti senza specificare le loro classi concrete.

Il modello AbstractFactory utilizza la composizione per delegare la responsabilità della creazione di oggetti in un'altra classe con il metodo Factory modello del utilizza l'ereditarietà e si basa sulla classe o sottoclasse derivata per creare l'oggetto

Dagli articoli di Oodesign :

Diagramma di classe di fabbrica :

Esempio: 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;
   }
}

La fabbrica non statica che implementa l'esempio FactoryMethod è disponibile in questo post:

Modelli di progettazione: metodo Factory vs Factory vs Factory astratto

Quando utilizzare: il client ha solo bisogno di una classe e non si preoccupa di quale implementazione concreta sta ottenendo.

Digaram di classe Metodo di fabbrica :

Quando utilizzare: il client non sa quali classi concrete sarà necessario creare in fase di esecuzione, ma vuole solo ottenere una classe che farà il lavoro.

Diagramma di classe di fabbrica astratta da dzone

Quando utilizzarlo: quando il sistema deve creare più famiglie di prodotti o si desidera fornire una libreria di prodotti senza esporre i dettagli dell'implementazione.

Gli esempi di codice sorgente negli articoli precedenti sono molto utili per comprendere chiaramente i concetti.

Domanda SE relativa con esempio di codice:

Modello di fabbrica. Quando utilizzare i metodi di fabbrica?

differenze:

1. Le classi Factory astratte sono spesso implementate con i metodi Factory, ma possono anche essere implementate usando Prototype
2. I progetti iniziano con il metodo Factory (meno complicati, più personalizzabili, le sottoclassi proliferano) e si evolvono verso altri schemi di creazione (più flessibili, più complessi) dove è necessaria maggiore flessibilità.
3. I metodi di fabbrica sono generalmente chiamati all'interno dei metodi modello.

Altri articoli utili:

factory_method from sourcemaking

abstract_factory dalla creazione di sorgenti

abstract-factory-design-pattern di journaldev

Esempio / Scenario per Abstract Factory

Vivo in un posto dove piove nella stagione delle piogge, nevica in inverno e caldo e soleggiato in estate. Ho bisogno di diversi tipi di vestiti per proteggermi dagli elementi. Per farlo vado al negozio vicino a casa mia e chiedo vestiti / oggetti per proteggermi. Il negoziante mi dà l'oggetto appropriato in base all'ambiente e alla profondità della mia tasca. Gli articoli che mi offre sono dello stesso livello di qualità e fascia di prezzo. Dal momento che è a conoscenza dei miei standard, è facile per lui farlo. Ma quando un ragazzo ricco dall'altra parte della strada presenta gli stessi requisiti, ottiene un oggetto costoso e di marca. Una cosa evidente è che tutti gli articoli che mi dà si completano a vicenda in termini di qualità, standard e costi. Si può dire che vanno l'uno con l'altro. Lo stesso vale per gli oggetti che ottiene questo ricco.

Quindi, guardando lo scenario sopra, ora apprezzo l'efficienza del negoziante. Posso sostituire questo negoziante con un negozio astratto. Gli oggetti che otteniamo con oggetti astratti e io e i ricchi come clienti prospettici. Tutto ciò di cui abbiamo bisogno è il prodotto / articolo adatto alle nostre esigenze.

Ora riesco a vedermi facilmente considerando un negozio online che offre una serie di servizi ai suoi numerosi clienti. Ogni client appartiene a uno dei tre gruppi. Quando un utente del gruppo premium apre il sito ottiene un'ottima interfaccia utente, riquadro pubblicitario altamente personalizzato, più opzioni nei menu ecc. Questo stesso set di funzionalità viene presentato all'utente gold ma la funzionalità nel menu è inferiore, le pubblicità sono per lo più pertinenti, e leggermente meno interfaccia utente egronomica. L'ultimo è il mio tipo di utente, un utente "gruppo libero". Sono appena servito abbastanza per non offendermi. L'interfaccia utente è un minimo indispensabile, le pubblicità sono così fuori strada così tanto che non so cosa ci sia dentro, infine il menu ha solo effettuato il logout.

Se avessi la possibilità di creare qualcosa di simile a questo sito, prenderei sicuramente in considerazione il modello astratto di fabbrica.

Prodotti astratti: riquadro pubblicitario, menu, pittore UI.
Fabbrica astratta: esperienza utente del Web Store
Fabbrica concreata: esperienza utente Premium, esperienza utente Gold, esperienza utente generale.

Molte persone potrebbero sentirsi sorprese, ma questa domanda non è corretta . Se senti questa domanda durante un'intervista, devi aiutare l'intervistatore a capire dov'è la confusione.

Partiamo dal fatto che non esiste un modello concreto che si chiama solo "Fabbrica". C'è un modello che si chiama "Fabbrica astratta", e c'è un modello che si chiama "Metodo di fabbrica".

Allora, cosa significa "Fabbrica" ​​allora? uno dei seguenti (tutti possono essere considerati corretti, a seconda dell'ambito del riferimento):

• Alcune persone lo usano come alias (scorciatoia) per " Fabbrica astratta ".
• Alcune persone lo usano come alias (scorciatoia) per " Metodo di fabbrica ".
• Alcune persone lo usano come nome più generale per tutti i modelli di fabbrica / creazione. Ad esempio, sia "Fabbrica astratta" che "Metodo di fabbrica" ​​sono Fabbriche.

E, sfortunatamente , molte persone usano "Factory" per indicare un altro tipo di fabbrica, che crea fabbrica o fabbriche (o le loro interfacce). Basato sulla loro teoria:

Il prodotto implementa IProduct, creato da Factory, che implementa IFactory, creato da AbstractFactory.

Per capire quanto sia sciocco, continuiamo la nostra equazione:

AbstractFactory implementa IAbstractFactory, creato da ... AbstractAbstractFactory ???

Spero che tu capisca il punto. Non confonderti e per favore non inventare cose che non esistono per la ragione.

-

PS : Factory for Products è AbstractFactory e Factory for Abstract Factories sarebbe solo un altro esempio di 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
} 

Le definizioni del libro di testo sono già fornite da altre risposte. Ho pensato di fornire anche un esempio.

Quindi qui PizzaIngredientsFactoryc'è una fabbrica astratta in quanto fornisce metodi per creare una famiglia di prodotti correlati.

Si noti che ogni metodo nella fabbrica astratta è un metodo di fabbrica in sé. Like createDough()è di per sé un metodo di fabbrica le cui implementazioni concrete saranno fornite da sottoclassi simili NYPizzaIngredientsFactory. Quindi, usando questo ogni posizione diversa può creare istanze di ingredienti concreti che appartengono alla loro posizione.

Metodo di fabbrica

Fornisce istanza di attuazione concreta

Nell'esempio:
- createDough()- fornisce un'implementazione concreta per l'impasto. Quindi questo è un metodo di fabbrica

Fabbrica astratta

Fornisce un'interfaccia per creare una famiglia di oggetti correlati

Nell'esempio:
- PizzaIngredientsFactoryè una fabbrica di astratto in quanto consente di creare un insieme correlato di oggetti come Dough, Clams, Sauce. Per la creazione di ogni famiglia di oggetti fornisce un metodo di fabbrica.

Esempio da Head First modelli di progettazione

Ho alcuni punti per contribuire con la risposta di John come segue:

La fabbrica astratta è una fabbrica di fabbriche!

Con il "Factory Method" (perché solo "Factory" è ambigua), si producono le implementazioni ( Lemon, Orange, ecc) di una particolare interfaccia - per esempio, IFruit. Questa fabbrica potrebbe essere chiamata CitricFruitFactory.

Ma ora vuoi creare un altro tipo di frutto che CitricFruitFactory non è in grado di creare. Forse il codice di CitricFruitFactorynon avrebbe senso se ne crei uno Strawberry(la fragola non è un frutto citrico!).

Quindi potresti creare una nuova fabbrica chiamata RedFruitFactory che produce Strawberry, Raspberrye così via

Come ha detto John Feminella: "Con il modello Abstract Factory, produci implementazioni di una particolare interfaccia Factory, ad esempio IFruitFactory. Ognuno di questi sa come creare diversi tipi di frutta".

Quelle implementazioni di IFruitFactorysono CitricFruitFactorye RedFruitFactory!

Le mie fonti sono: StackOverflow, tutorialspoint.com, programmers.stackexchange.come CodeProject.com.

Factory Method(chiamato anche Factory) è per il client di disaccoppiamento di Interfaceun'implementazione. Per esempio abbiamo Shapeun'interfaccia con due Circlee Squareimplementazioni. Abbiamo definito una classe factory con un metodo factory con un parametro determinante come Typee una nuova implementazione correlata Shapedell'interfaccia.

Abstract Factorycontiene diversi metodi di fabbrica o un'interfaccia di fabbrica con diverse implementazioni di fabbrica. Per il prossimo esempio sopra abbiamo Colorun'interfaccia con due Rede Yellowimplementazioni. Abbiamo definito ShapeColorFactoryun'interfaccia con due RedCircleFactorye YellowSquareFactory. Il seguente codice per spiegare questo concetto:

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();
    }
} 

Qui la differenza tra FactoryMethode AbstractFactory. Factory Methodcome semplicemente restituisce una classe concreta di un'interfaccia ma Abstract Factoryrestituisce factory of factory. In altre parole, Abstract Factoryrestituiscono diverse combinazioni di una serie di interfacce.

Spero che la mia spiegazione sia utile.

La principale differenza in quelle fabbriche è quando cosa vuoi fare con le fabbriche e quando vuoi usarlo.

A volte, quando si esegue il CIO (inversione di controllo, ad es. Iniezione del costruttore), si sa che è possibile creare oggetti solidi. Come menzionato nell'esempio sopra dei frutti, se sei pronto a creare oggetti di frutti, puoi usare un semplice modello di fabbrica .

Ma molte volte, non si desidera creare oggetti solidi, arriveranno più avanti nel flusso del programma. Ma la configurazione ti dice che tipo di factory vuoi usare all'avvio, invece di creare oggetti, puoi trasferire le fabbriche che derivano da una classe factory comune al costruttore in IOC.

Quindi, penso che riguardi anche la durata e la creazione dell'oggetto.

Entrambi Factory Methode Abstract Factorymantenere i clienti disaccoppiati dai tipi concreti. Entrambi creano oggetti, ma il Factorymetodo usa l'ereditarietà mentre Abstract Factoryusa la composizione.

Il Factory Methodè ereditata sottoclassi per creare gli oggetti concreti (prodotti), mentre Abstract Factoryfornire l'interfaccia per la creazione della famiglia di prodotti correlati e sottoclasse di questi interfaccia definire come creare prodotti correlati.

Quindi queste sottoclassi quando vengono istanziate vengono passate nelle classi di prodotti in cui vengono utilizzate come tipo astratto. I prodotti correlati in un Abstract Factorysono spesso implementati utilizzando Factory Method.

Estendere la risposta di John Feminella:

Apple, Banana, CherryAttrezzi FruitFactorye che ha un metodo chiamato Create, che è il solo responsabile della creazione di mela o banana o ciliegio. Hai finito, con il tuo Factorymetodo.

Ora, vuoi Createun'insalata speciale dai tuoi frutti e arriva la tua Fabbrica astratta . Abstract Factory sa come creare la tua insalata speciale con mela, banana e ciliegia.

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.
    }
}

Per definizione possiamo trascinare le differenze di due:

Factory: un'interfaccia viene utilizzata per creare un oggetto, ma la sottoclasse decide quale classe creare un'istanza. La creazione dell'oggetto viene eseguita quando è richiesta.

Fabbrica astratta: il modello Fabbrica astratta funge da super fabbrica che crea altre fabbriche. Nel modello Abstract Factory un'interfaccia è responsabile della creazione di un insieme di oggetti correlati o oggetti dipendenti senza specificare le loro classi concrete.

Quindi, nelle definizioni sopra possiamo enfatizzare una particolare differenza. vale a dire, il modello Factory è responsabile della creazione di oggetti e Abstract Factory è responsabile della creazione di un insieme di oggetti correlati; ovviamente entrambi attraverso un'interfaccia.

Modello di fabbrica:

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();
 }
}

Modello astratto di fabbrica:

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();
        }
    }

Controlla qui: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm sembra che il metodo Factory utilizzi una particolare classe (non astratta) come classe base mentre Abstract factory utilizza una classe astratta per questo. Inoltre, se si utilizza un'interfaccia anziché la classe astratta, il risultato sarà un'implementazione diversa del modello di Fabbrica astratta.

: D

Abstract Factory è un modello per la creazione di diversi tipi di interfacce. Supponiamo di avere un progetto che richiede di analizzare diversi tipi di file csv contenenti quantità, prezzo e informazioni specifiche sull'articolo come alcuni contengono dati su frutti altri sui cioccolatini e quindi dopo l'analisi è necessario aggiornare queste informazioni nel loro database corrispondente, quindi ora è possibile avere una fabbrica astratta che ti restituisce una fabbrica di parser e modificatore e quindi questa fabbrica di parser può restituirti un oggetto parser di cioccolato, un oggetto Parser di frutta ecc. e allo stesso modo un modificatore Factory può restituire un oggetto modificatore di cioccolato, un oggetto modificatore di frutta, ecc.

Penso che possiamo capire la differenza tra questi due vedendo un codice di esempio 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;
    }

}

Ora la domanda è quale modo di creare dovresti usare e perché: Il primo modo (nessun modello, solo semplice costruttore): creare da solo non è una buona idea, devi fare tutto il lavoro e il tuo codice cliente è legato l'implementazione particolare.

Il secondo modo (usando il modello Factory): ti offre il vantaggio di poter passare qualsiasi tipo di implementazione, che può fornire diversi tipi di qualcosa in base a una condizione (forse un parametro passato al metodo creativo).

Il terzo modo (usando il modello Abstract Factory): questo ti dà più flessibilità. Puoi trovare diversi tipi di creatori di qualcosa in base a una condizione (forse un parametro passato).

Nota che puoi sempre cavartela con il modello Factory combinando due condizioni insieme (che aumentano leggermente la complessità del codice e l'accoppiamento), immagino sia per questo che raramente vediamo casi d'uso nella vita reale del modello Abstract Factory.