Qual è la differenza di base tra i modelli Factory e Abstract Factory Design? [chiuso]

https://stackoverflow.com/questions/1001767

05-07-2019
|

Domanda

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

Soluzione

Con il modello Factory, produci istanze di implementazioni ( Apple , Banana , Cherry , ecc.) di una particolare interfaccia - ad esempio, IFruit .

Con il modello Abstract Factory, offri a chiunque la possibilità di fornire la propria fabbrica. Ciò consente al tuo magazzino di essere un IFruitFactory o un IJuiceFactory , senza che il tuo magazzino sia a conoscenza di frutta o succhi di frutta.

Altri suggerimenti

Fonte di queste informazioni tratte da: http://java.dzone.com / notizie / intro-design-patterns-astratto

Metodo astratto di fabbrica contro 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 di fabbrica utilizza interfacce e classi astratte per separare 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

Utilizza 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

Usa il modello Abstract Factory 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:

Abstract Factory Example 1

Questa specifica per i dischi per preparare diversi tipi di pasta in un pastificio si trova 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 pastaio no.

Esempio di fabbrica astratta 2:

L'attrezzatura per timbratura corrisponde alla Fabbrica astratta, in quanto è un interfaccia per 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 a i prodotti concreti.

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]
Ciò che ho scritto prima non è corretto 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.

The Abstract Factory Pattern

Fornisce un'interfaccia per la creazione famiglie di parenti o dipendenti oggetti senza specificare il loro classi concrete.
Il modello Abstract Factory è molto simile al metodo Factory modello. Una differenza tra il due è quello con la Fabbrica astratta modello, una classe delega il responsabilità dell'oggetto istanza su un altro oggetto tramite composizione mentre la Fabbrica Il modello di metodo utilizza l'ereditarietà e si basa su una sottoclasse per gestire il file istanza dell'oggetto desiderata.
In realtà, l'oggetto delegato utilizza frequentemente metodi di fabbrica per esegui l'istanza!

Modello di fabbrica

I modelli di fabbrica sono esempi di schemi creativi
I motivi di creazione astraggono il processo di istanza dell'oggetto. Essi nascondi come vengono creati gli oggetti e aiuta rendere indipendente l'intero sistema di come vengono creati i suoi oggetti e composta.
I modelli di creazione di classe si concentrano su l'uso dell'eredità per decidere il oggetto da istanziare Metodo di fabbrica
I motivi di creazione dell'oggetto si concentrano su la delega dell'istanza a un altro oggetto Fabbrica astratta

Riferimento: Fabbrica contro fabbrica astratta

Metodo factory: 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) - piuttosto, 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.

inserisci qui la descrizione dell

Differenza di base:

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

Metodo di fabbrica : definisce un'interfaccia per la creazione di un oggetto, ma lascia 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 creare 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 mentre il modello Metodo di fabbrica utilizza l'ereditarietà e si basa sulla classe o sottoclasse derivata per creare l'oggetto

Dagli oodesign articoli:

Factory diagramma di classe:

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:

Design Pattern: metodo Factory vs Factory vs Abstract Factory

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

Metodo di fabbrica digaram di classe:

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.

Fabbrica astratta diagramma di classe da dzone

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

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

Domanda SE correlata con esempio di codice:

Pattern di fabbrica. Quando utilizzare i metodi di fabbrica?

Differenze:

Le classi Factory astratte sono spesso implementate con i metodi Factory, ma possono anche essere implementate usando Prototype
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à.
I metodi di fabbrica sono generalmente chiamati in Metodi modello.

Altri articoli utili:

factory_method dalla produzione di sorgenti

abstract_factory dalla produzione di sorgenti

abstract-factory-design-pattern da 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 gruppo gratuito & # 8217; utente. 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 costruire qualcosa come questo sito, prenderei sicuramente in considerazione il modello astratto di fabbrica.

Prodotti astratti: riquadro pubblicitario, menu, pittore UI.
Abstract Factory: esperienza utente nel Web Store
Concreate Factory: esperienza utente Premium, esperienza utente Gold, esperienza utente generale.

Forse molte persone si sentiranno sorprese, ma questa domanda è errata . 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".

Quindi, cosa fa " Factory " intendi allora? uno dei seguenti (tutti possono essere considerati corretti, a seconda dell'ambito di riferimento):

Alcune persone lo usano come alias (scorciatoia) per " Abstract Factory " ;.
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. Per esempio. entrambi " Fabbrica astratta " e "Metodo di fabbrica" sono fabbriche.

E, purtroppo , molte persone usano " Factory " per indicare un altro tipo di fabbrica, che crea una 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.

P.S. : 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 PizzaIngredientsFactory è una fabbrica astratta in quanto fornisce metodi per creare una famiglia di prodotti correlati.

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

Metodo di fabbrica

Fornisce istanza di implementazione concreta

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

Fabbrica astratta

Fornisce interfaccia per creare una famiglia di oggetti correlati

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

Esempio da Head First design pattern

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

La fabbrica astratta è una fabbrica di fabbriche!

Con il "Metodo di fabbrica" (poiché solo "Factory" è ambiguo), produci implementazioni ( Lemon , Orange , ecc.) di una particolare interfaccia, ad esempio IFruit . Questa fabbrica potrebbe essere chiamata CitricFruitFactory .

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

Quindi potresti creare una nuova Factory chiamata RedFruitFactory che produce Strawberry , Raspberry , ecc.

Come diceva 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. & Quot;

Quelle implementazioni di IFruitFactory sono CitricFruitFactory e RedFruitFactory !

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

Metodo di fabbrica (chiamato anche Factory ) è per il client di disaccoppiamento di un'implementazione di Interface . Per esempio abbiamo un'interfaccia Shape con due implementazioni Circle e Square . Abbiamo definito una classe factory con un metodo factory con un parametro determinante come Type e una nuova implementazione correlata dell'interfaccia Shape .

Abstract Factory contiene diversi metodi di fabbrica o un'interfaccia di fabbrica di diverse implementazioni di fabbrica. Per il prossimo esempio abbiamo un'interfaccia Color con due implementazioni Red e Yellow . Abbiamo definito un'interfaccia ShapeColorFactory con due RedCircleFactory e 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 differenza tra FactoryMethod e AbstractFactory . Metodo di fabbrica in quanto restituisce semplicemente una classe concreta di un'interfaccia ma Fabbrica astratta restituisce fabbrica di fabbrica . In altre parole, Abstract Factory restituisce 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 esegui IOC (inversione di controllo, ad es. iniezione del costruttore), sai che puoi creare oggetti solidi. Come menzionato nell'esempio sopra dei frutti, se sei pronto a creare oggetti di frutti, puoi utilizzare il 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.

Sia Metodo di fabbrica che Fabbrica astratta mantengono i clienti disaccoppiati dai tipi concreti. Entrambi creano oggetti, ma il metodo Factory utilizza l'ereditarietà mentre Abstract Factory utilizza la composizione.

Il Metodo di fabbrica è ereditato in sottoclassi per creare oggetti concreti (prodotti) mentre Fabbrica astratta fornisce un'interfaccia per la creazione della famiglia di prodotti correlati e la sottoclasse di queste interfacce definisce 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 Factory sono spesso implementati utilizzando Factory Method .

Estensione della risposta di John Feminella:

Apple , Banana , Cherry implementa FruitFactory e che ha un metodo chiamato Crea che è l'unico responsabile della creazione di Apple, Banana o Cherry. Hai finito, con il tuo metodo Factory .



 Ora, vuoi  Creare  un'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 classe particolare (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 Abstract Factory. 

: 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 diversi su 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 creazione dovresti usare e perché:
Il primo modo (nessun modello, solo semplice costruttore): creare da soli non è una buona idea, devi fare tutto il lavoro e il tuo codice client è legato alla particolare implementazione. 

 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 creazionale). 

 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 .



	
		
			Autorizzato sotto: CC-BY-SA insieme a attribuzione
			Non affiliato a StackOverflow