Was ist der grundlegende Unterschied zwischen den Factory- und den Abstract Factory-Mustern?

Mit der Fabrik Muster erzeugen Sie Instanzen von Implementierungen ( Apple, Banana, Cherry, usw.) einer bestimmten Schnittstelle - sagen wir IFruit.

Mit dem Abstract Factory-Muster bieten Sie jedem die Möglichkeit, seine eigene Fabrik bereitzustellen. Auf diese Weise kann Ihr Lager entweder ein IFruitFactoryoder ein Lager sein IJuiceFactory, ohne dass Ihr Lager etwas über Obst oder Säfte wissen muss.

Quelle für diese Informationen: http://java.dzone.com/news/intro-design-patterns-abstract

Abstrakte Fabrik vs. Fabrikmethode

Die Methoden einer Abstract Factory werden als Factory-Methoden implementiert. Sowohl das Abstract Factory Pattern als auch das Factory Method Pattern entkoppeln das Client-System von den tatsächlichen Implementierungsklassen durch die abstrakten Typen und Fabriken. Die Factory-Methode erstellt Objekte durch Vererbung, während die Abstract Factory Objekte durch Komposition erstellt.

Das Abstract Factory Pattern besteht aus einer AbstractFactory, einer ConcreteFactory, einem AbstractProduct, einem ConcreteProduct und einem Client.

Wie zu implementieren

Das abstrakte Factory-Muster kann mithilfe des Factory-Methodenmusters, des Prototypmusters oder des Singleton-Musters implementiert werden. Das ConcreteFactory-Objekt kann als Singleton implementiert werden, da nur eine Instanz des ConcreteFactory-Objekts benötigt wird.

Das Factory-Methodenmuster ist eine vereinfachte Version des Abstract Factory-Musters. Das Factory-Methodenmuster ist für die Erstellung von Produkten verantwortlich, die zu einer Familie gehören, während das abstrakte Factory-Muster mehrere Produktfamilien behandelt.

Die Factory-Methode verwendet Schnittstellen und abstrakte Klassen, um den Client von der Generatorklasse und den resultierenden Produkten zu entkoppeln. Abstract Factory verfügt über einen Generator, der ein Container für verschiedene Factory-Methoden ist, sowie über Schnittstellen, die den Client vom Generator und den Produkten entkoppeln.

Wann wird das Factory-Methodenmuster verwendet?

Verwenden Sie das Factory-Methodenmuster, wenn ein Client von einem bestimmten Produkt, das er verwendet, entkoppelt werden muss. Verwenden Sie die Factory-Methode, um einen Client von der Verantwortung für das Erstellen und Konfigurieren von Instanzen eines Produkts zu entbinden.

Wann wird das abstrakte Factory-Muster verwendet?

Verwenden Sie das Abstract Factory-Muster, wenn Clients von Produktklassen entkoppelt werden müssen. Besonders nützlich für die Programmkonfiguration und -änderung. Das Abstract Factory-Muster kann auch Einschränkungen erzwingen, welche Klassen mit anderen verwendet werden müssen. Es kann eine Menge Arbeit sein, neue konkrete Fabriken zu bauen.

Beispiele:

Beispiel 1 für eine abstrakte Fabrik

Diese Spezifikation für die Datenträger zum Zubereiten verschiedener Arten von Nudeln in einem Nudelhersteller ist die Abstract Factory, und jeder bestimmte Datenträger ist eine Factory. Alle Fabriken (Pasta Maker Disks) erben ihre Eigenschaften von der abstrakten Factory. Jede einzelne Festplatte enthält Informationen zum Erstellen der Nudeln, der Nudelhersteller jedoch nicht.

Abstract Factory Beispiel 2:

Die Stanzausrüstung entspricht der Abstract Factory, da sie eine Schnittstelle für Vorgänge ist, mit denen abstrakte Produktobjekte erstellt werden. Die Matrizen entsprechen der Betonfabrik, da sie ein Betonprodukt erzeugen. Jede Teilekategorie (Motorhaube, Tür usw.) entspricht dem abstrakten Produkt. Bestimmte Teile (dh Fahrertür für 99 Camry) entsprechen den Betonprodukten.

Beispiel für eine Fabrikmethode:

Die Spielzeugfirma entspricht dem Schöpfer, da sie die Fabrik verwenden kann, um Produktobjekte zu erstellen. Die Abteilung des Spielzeugherstellers, der eine bestimmte Art von Spielzeug (Pferd oder Auto) herstellt, entspricht dem ConcreteCreator.

Fabrikmuster: Die Fabrik produziert IProduct-Implementierungen

Abstraktes Fabrikmuster: Eine Fabrikfabrik produziert IFactories, die wiederum IProducts produzieren :)

[Update gemäß den Kommentaren]
Was ich früher geschrieben habe, ist laut Wikipedia zumindest nicht korrekt . Eine abstrakte Fabrik ist einfach eine Fabrikschnittstelle. Damit können Sie Ihre Fabriken zur Laufzeit wechseln, um verschiedene Fabriken in verschiedenen Kontexten zuzulassen. Beispiele könnten verschiedene Fabriken für verschiedene Betriebssysteme, SQL-Anbieter, Middleware-Treiber usw. sein.

Das abstrakte Fabrikmuster

• Stellen Sie eine Schnittstelle zum Erstellen von Familien verwandter oder abhängiger Objekte bereit, ohne deren konkrete Klassen anzugeben.

• Das Abstract Factory-Muster ist dem Factory Method-Muster sehr ähnlich. Ein Unterschied zwischen beiden besteht darin, dass beim Abstract-Factory-Muster eine Klasse die Verantwortung für die Objektinstanziierung über die Komposition an ein anderes Objekt delegiert, während das Factory-Methodenmuster die Vererbung verwendet und sich auf eine Unterklasse stützt, um die gewünschte Objektinstanziierung zu handhaben.

• Tatsächlich verwendet das delegierte Objekt häufig Factory-Methoden, um die Instanziierung durchzuführen!

Fabrikmuster

• Fabrikmuster sind Beispiele für Schöpfungsmuster

• Schöpfungsmuster abstrahieren den Objektinstanziierungsprozess. Sie verbergen, wie Objekte erstellt werden, und helfen dabei, das Gesamtsystem unabhängig davon zu machen, wie seine Objekte erstellt und zusammengesetzt werden.

• Klassenerstellungsmuster konzentrieren sich auf die Verwendung der Vererbung, um das zu instanziierende Objekt zu bestimmen. Factory-Methode

• Objekterstellungsmuster konzentrieren sich auf die Delegierung der Instanziierung an ein anderes Objekt Abstract Factory

Referenz: Factory vs Abstract Factory

Factory-Methode: Sie haben eine Factory, die Objekte erstellt, die von einer bestimmten Basisklasse abgeleitet sind

Abstrakte Fabrik: Sie haben eine Fabrik, die andere Fabriken erstellt , und diese Fabriken erstellen wiederum Objekte, die von Basisklassen abgeleitet sind. Sie tun dies, weil Sie häufig nicht nur ein einzelnes Objekt erstellen möchten (wie bei der Factory-Methode), sondern eine Sammlung verwandter Objekte erstellen möchten.

Abstract Factory ist eine Schnittstelle zum Erstellen verwandter Objekte, die Factory-Methode ist jedoch eine Methode. Die abstrakte Fabrik wird durch die Fabrikmethode implementiert.

Grundlegender Unterschied:

Factory: Erstellt Objekte, ohne die Instanziierungslogik dem Client zur Verfügung zu stellen.

Factory-Methode : Definieren Sie eine Schnittstelle zum Erstellen eines Objekts, lassen Sie jedoch die Unterklassen entscheiden, welche Klasse instanziiert werden soll. Mit der Factory-Methode kann eine Klasse die Instanziierung auf Unterklassen verschieben

Abstract Factory : Bietet eine Schnittstelle zum Erstellen von Familien verwandter oder abhängiger Objekte, ohne deren konkrete Klassen anzugeben.

Das AbstractFactory- Muster verwendet die Komposition, um die Verantwortung für das Erstellen eines Objekts an eine andere Klasse zu delegieren, während das Factory-Methodenmuster die Vererbung verwendet und sich beim Erstellen des Objekts auf abgeleitete Klassen oder Unterklassen stützt

Aus oodesign Artikeln:

Factory - Klassendiagramm:

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

In diesem Beitrag finden Sie ein Beispiel für die Implementierung von FactoryMethod in einer nicht statischen Factory:

Entwurfsmuster: Factory vs Factory-Methode vs Abstract Factory

Verwendungszweck: Der Client benötigt nur eine Klasse und kümmert sich nicht darum, welche konkrete Implementierung er erhält.

Factory Method Klasse Digaram:

Verwendungszweck: Der Client weiß nicht, welche konkreten Klassen zur Laufzeit erstellt werden müssen, sondern möchte nur eine Klasse erhalten, die die Aufgabe übernimmt.

Abstract Factory Klassendiagramm von dzone

Verwendungszweck: Wenn Ihr System mehrere Produktfamilien erstellen muss oder Sie eine Produktbibliothek bereitstellen möchten, ohne die Implementierungsdetails offenzulegen.

Quellcodebeispiele in den obigen Artikeln sind sehr gut, um die Konzepte klar zu verstehen.

Verwandte SE-Frage mit Codebeispiel:

Fabrikmuster. Wann werden Werksmethoden angewendet?

Unterschiede:

1. Abstract Factory-Klassen werden häufig mit Factory-Methoden implementiert, können jedoch auch mit Prototype implementiert werden
2. Entwürfe beginnen mit der Factory-Methode (weniger kompliziert, anpassbarer, Unterklassen vermehren sich) und entwickeln sich zu anderen Kreationsmustern (flexibler, komplexer), bei denen mehr Flexibilität erforderlich ist.
3. Factory-Methoden werden normalerweise in Template-Methoden aufgerufen.

Andere nützliche Artikel:

factory_method aus der Quellenherstellung

abstract_factory aus der Quellenherstellung

Abstract-Factory-Design-Muster von journaldev

Beispiel / Szenario für Abstract Factory

Ich lebe an einem Ort, an dem es in der Regenzeit regnet, im Winter schneit und im Sommer heiß und sonnig. Ich brauche verschiedene Arten von Kleidung, um mich vor den Elementen zu schützen. Dazu gehe ich in den Laden in der Nähe meines Hauses und bitte um Kleidung / Gegenstände, um mich zu schützen. Der Ladenbesitzer gibt mir den passenden Artikel entsprechend der Umgebung und Tiefe meiner Tasche. Die Artikel, die er mir gibt, sind von gleicher Qualität und Preisklasse. Da er sich meiner Standards bewusst ist, fällt es ihm leicht, dies zu tun. Aber wenn ein reicher Mann von der anderen Straßenseite die gleichen Anforderungen hat, bekommt er einen teuren Markenartikel. Auffällig ist, dass sich alle Artikel, die er mir gibt, in Bezug auf Qualität, Standard und Kosten ergänzen. Man kann sagen, dass sie miteinander gehen. Gleiches gilt für die Gegenstände, die dieser reiche Kerl bekommt.

Wenn ich mir das obige Szenario anschaue, schätze ich jetzt die Effizienz des Ladenbesitzers. Ich kann diesen Ladenbesitzer durch einen Abstract Shop ersetzen. Die Gegenstände, die wir mit abstrakten Gegenständen bekommen, und ich und die Reichen als Perspektivkunden. Alles was wir brauchen ist das Produkt / der Artikel, der unseren Bedürfnissen entspricht.

Jetzt kann ich mir leicht vorstellen, einen Online-Shop in Betracht zu ziehen, der seinen zahlreichen Kunden eine Reihe von Dienstleistungen bietet. Jeder Kunde gehört zu einer der drei Gruppen. Wenn ein Premium-Gruppenbenutzer die Website öffnet, erhält er eine großartige Benutzeroberfläche, einen hochgradig angepassten Werbebereich, mehr Optionen in den Menüs usw. Dieselben Funktionen werden Goldbenutzern angeboten, aber die Funktionen im Menü sind geringer. Anzeigen sind meistens relevant. und etwas weniger egronomische Benutzeroberfläche. Zuletzt ist meine Art von Benutzer, ein Benutzer der 'freien Gruppe'. Ich werde gerade genug bedient, damit ich nicht beleidigt werde. Die Benutzeroberfläche ist ein absolutes Minimum, Werbung ist so weit vom Kurs entfernt, dass ich nicht weiß, was darin enthalten ist. Schließlich hat sich das Menü nur abgemeldet.

Wenn ich die Möglichkeit bekomme, so etwas wie diese Website zu erstellen, würde ich definitiv Abstract Factory Pattern in Betracht ziehen.

Abstrakte Produkte: Werbebereich, Menü, UI-Maler.
Abstrakte Factory: Web Store-Benutzererfahrung
Concreate Factory: Premium-Benutzererfahrung, Gold-Benutzererfahrung, allgemeine Benutzererfahrung.

Viele Menschen werden sich vielleicht überrascht fühlen, aber diese Frage ist falsch . Wenn Sie diese Frage während eines Interviews hören, müssen Sie dem Interviewer helfen, zu verstehen, wo die Verwirrung liegt.

Beginnen wir mit der Tatsache, dass es kein konkretes Muster gibt, das nur "Fabrik" genannt wird. Es gibt ein Muster, das als "abstrakte Fabrik" bezeichnet wird, und es gibt ein Muster, das als "Fabrikmethode" bezeichnet wird.

Was bedeutet dann "Fabrik"? eine der folgenden (alle können je nach Umfang der Referenz als korrekt angesehen werden):

• Einige Leute benutzen es als Alias ​​(Abkürzung) für " Abstract Factory ".
• Einige Leute verwenden es als Alias ​​(Abkürzung) für " Factory Method ".
• Einige Leute verwenden es als allgemeineren Namen für alle Fabrik- / Kreationsmuster. ZB sind sowohl "Abstract Factory" als auch "Factory Method" Fabriken.

Und leider verwenden viele Leute "Fabrik", um eine andere Art von Fabrik zu bezeichnen, die Fabrik oder Fabriken (oder deren Schnittstellen) schafft. Basierend auf ihrer Theorie:

Das Produkt implementiert IProduct, das von Factory erstellt wird, und implementiert IFactory, das von AbstractFactory erstellt wird.

Um zu verstehen, wie dumm das ist, setzen wir unsere Gleichung fort:

AbstractFactory implementiert IAbstractFactory, das erstellt von ... AbstractAbstractFactory ???

Ich hoffe du verstehst den Punkt. Seien Sie nicht verwirrt und erfinden Sie bitte keine Dinge, die es aus gutem Grund nicht gibt.

- -

PS : Factory for Products ist AbstractFactory, und Factory for Abstract Factories wäre nur ein weiteres Beispiel für 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
} 

Die Lehrbuchdefinitionen werden bereits durch andere Antworten bereitgestellt. Ich dachte, ich würde auch ein Beispiel dafür liefern.

Hier PizzaIngredientsFactoryist also eine abstrakte Fabrik , die Methoden zum Erstellen einer Familie verwandter Produkte bietet.

Beachten Sie, dass jede Methode in der Abstract-Factory eine Factory-Methode für sich ist. Like createDough()ist an sich eine Factory-Methode, deren konkrete Implementierungen von Unterklassen wie bereitgestellt werden NYPizzaIngredientsFactory. Wenn Sie dies verwenden, kann jeder unterschiedliche Standort Instanzen konkreter Zutaten erstellen, die zu ihrem Standort gehören.

Fabrikmethode

Bietet eine konkrete Implementierung

Im Beispiel:
-createDough() - liefert eine konkrete Umsetzung für Teig. Das ist also eine Fabrikmethode

Abstrakte Fabrik

Bietet eine Schnittstelle zum Erstellen einer Familie verwandter Objekte

Im Beispiel:
- PizzaIngredientsFactoryist eine abstrakte Factory, mit der eine verwandte Menge von Objekten wie ,, erstellt Doughwerden Clamskann.Sauce . Zum Erstellen jeder Objektfamilie wird eine Factory-Methode bereitgestellt.

Beispiel aus Head First-Entwurfsmustern

Ich habe einige Punkte, die ich mit Johns Antwort wie folgt beitragen kann:

Abstrakte Fabrik ist eine Fabrik der Fabriken!

Mit der „Factory Method“ (weil nur „Factory“ mehrdeutig ist), erzeugen Sie Implementierungen ( Lemon, Orangeusw.) eine bestimmten Schnittstelle - sagt sie IFruit. Diese Fabrik könnte genannt werden CitricFruitFactory.

Jetzt möchten Sie jedoch andere Obstsorten erstellen, die von der CitricFruitFactory nicht erstellt werden können. Vielleicht macht der Code von CitricFruitFactorykeinen Sinn, wenn Sie einen Strawberrydarin erstellen (Erdbeere ist keine Zitronenfrucht!).

So haben Sie eine neue Fabrik schaffen könnte genannt , RedFruitFactorydie produziert Strawberry, Raspberryusw.

Wie John Feminella sagte: "Mit dem Abstract Factory-Muster erstellen Sie Implementierungen einer bestimmten Factory-Schnittstelle - z IFruitFactory. B .. Jeder von ihnen weiß, wie man verschiedene Obstsorten erstellt."

Die Implementierungen von IFruitFactorysind CitricFruitFactoryund RedFruitFactory!

Meine Quellen sind: StackOverflow, tutorialspoint.com, programmers.stackexchange.comund CodeProject.com.

Factory Method(auch genannt Factory) dient zum Entkoppeln des Clients einer InterfaceImplementierung. Zum Beispiel haben wir eine ShapeSchnittstelle mit zwei Circleund SquareImplementierungen. Wir haben eine Factory-Klasse mit einer Factory-Methode mit einem Bestimmungsparameter wie Typeund einer neuen verwandten Implementierung der ShapeSchnittstelle definiert.

Abstract Factoryenthält mehrere Factory-Methoden oder eine Factory-Schnittstelle von mehreren Factory-Implementierungen. Für das nächste obige Beispiel haben wir eine ColorSchnittstelle mit zwei Redund YellowImplementierungen. Wir haben eine ShapeColorFactorySchnittstelle mit zwei RedCircleFactoryund definiert YellowSquareFactory. Der folgende Code zur Erläuterung dieses Konzepts:

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

Hier Unterschied zwischen FactoryMethodund AbstractFactory. Factory MethodGeben Sie einfach eine konkrete Klasse einer Schnittstelle zurück, aber Abstract Factorykehren Sie zurück factory of factory. Mit anderen Worten, Abstract Factorygeben Sie verschiedene Kombinationen einer Reihe von Schnittstellen zurück.

Ich hoffe meine Erklärung hilfreich.

Der Hauptunterschied in diesen Fabriken besteht darin, wann Sie mit den Fabriken arbeiten möchten und wann Sie sie verwenden möchten.

Wenn Sie IOC (Inversion der Steuerung, z. B. Konstruktorinjektion) ausführen, wissen Sie manchmal, dass Sie feste Objekte erstellen können. Wie im obigen Beispiel für Früchte erwähnt, können Sie ein einfaches Fabrikmuster verwenden, wenn Sie bereit sind, Objekte von Früchten zu erstellen .

Oft möchten Sie jedoch keine festen Objekte erstellen, diese werden später im Programmablauf angezeigt. Die Konfiguration gibt jedoch an, welche Art von Factory Sie zu Beginn verwenden möchten. Anstatt Objekte zu erstellen, können Sie Fabriken, die von einer gemeinsamen Factory-Klasse abgeleitet sind, an den Konstruktor in IOC weitergeben.

Ich denke, es geht auch um die Lebensdauer und Erstellung des Objekts.

Beides Factory Methodund Abstract Factoryhalten die Kunden von den konkreten Typen entkoppelt. Beide erstellen Objekte, aber die FactoryMethode verwendet die VererbungAbstract Factory die Komposition verwendet wird.

Das Factory Methodwird in Unterklassen vererbt, um die konkreten Objekte (Produkte) zu erstellen, während Abstract Factorydie Schnittstelle zum Erstellen der Familie verwandter Produkte und die Unterklasse dieser Schnittstelle das Erstellen verwandter Produkte definieren.

Diese Unterklassen werden dann beim Instanziieren an Produktklassen übergeben, wo sie als abstrakter Typ verwendet werden. Die verwandten Produkte in einem Abstract Factorywerden häufig mit implementiert Factory Method.

Antwort von John Feminella erweitern:

Apple, Banana, CherryArbeitsgeräte FruitFactoryund die eine Methode aufgerufen , Createdie die Schaffung von Apple oder Banane oder Kirsche allein verantwortlich ist. Du bist fertig mit deiner FactoryMethode.

Jetzt möchten Sie Createeinen speziellen Salat aus Ihren Früchten und da kommt Ihre abstrakte Fabrik . Abstract Factory weiß, wie man aus Apfel, Banane und Kirsche einen speziellen Salat kreiert.

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 Definition können wir die Unterschiede von zwei herausziehen:

Factory: Eine Schnittstelle wird zum Erstellen eines Objekts verwendet, aber die Unterklasse entscheidet, welche Klasse instanziiert werden soll. Die Erstellung des Objekts erfolgt bei Bedarf.

Abstrakte Fabrik: Das abstrakte Fabrikmuster fungiert als Superfabrik, die andere Fabriken schafft. Im Abstract Factory-Muster ist eine Schnittstelle dafür verantwortlich, eine Reihe verwandter Objekte oder abhängiger Objekte zu erstellen, ohne deren konkrete Klassen anzugeben.

In den obigen Definitionen können wir also einen bestimmten Unterschied hervorheben. Das heißt, das Factory-Muster ist für das Erstellen von Objekten verantwortlich, und Abstract Factory ist für das Erstellen einer Reihe verwandter Objekte verantwortlich. offensichtlich beides über eine Schnittstelle.

Fabrikmuster:

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

Abstraktes Fabrikmuster:

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

Überprüfen Sie hier: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm Es scheint, dass die Factory-Methode eine bestimmte Klasse (nicht abstrakt) als Basisklasse verwendet, während die Abstract-Factory eine abstrakte Klasse verwendet. Auch wenn eine Schnittstelle anstelle einer abstrakten Klasse verwendet wird, ist das Ergebnis eine andere Implementierung des Abstract Factory-Musters.

: D.

Abstract Factory ist eine Vorlage zum Erstellen verschiedener Arten von Schnittstellen. Angenommen, Sie haben ein Projekt, bei dem Sie verschiedene Arten von CSV-Dateien analysieren müssen, die mengen-, preis- und artikelspezifische Informationen enthalten, z. B. einige Daten zu Früchten, andere zu Pralinen. Nach dem Parsen müssen Sie diese Informationen in der entsprechenden Datenbank aktualisieren, damit Sie sie jetzt haben können Eine abstrakte Fabrik, die Ihnen die Parser- und Modifikatorfabrik zurückgibt, und diese Parserfabrik können Ihnen das Schokoladenparserobjekt, das Fruchtparserobjekt usw. zurückgeben. In ähnlicher Weise kann die Modifikatorfabrik das Schokoladenmodifikatorobjekt, das Fruchtmodifikatorobjekt usw. zurückgeben.

Ich denke, wir können den Unterschied zwischen diesen beiden anhand eines Java8-Beispielcodes verstehen:

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

}

Die Frage ist nun, welche Art der Erstellung Sie verwenden sollten und warum: Der erste Weg (kein Muster, nur einfacher Konstruktor): Das Erstellen selbst ist keine gute Idee, Sie müssen die ganze Arbeit erledigen und Ihr Client-Code ist daran gebunden die besondere Umsetzung.

Der zweite Weg (unter Verwendung des Factory-Musters): bietet Ihnen den Vorteil, dass Sie jede Art von Implementierung übergeben können, die je nach Bedingung unterschiedliche Arten von etwas bereitstellen kann (möglicherweise ein Parameter, der an die Erstellungsmethode übergeben wird).

Der dritte Weg (unter Verwendung des Abstract Factory-Musters): Dies gibt Ihnen mehr Flexibilität. Sie können verschiedene Arten von Erstellern von etwas finden, die auf einer bestimmten Bedingung basieren (möglicherweise wurde ein Parameter übergeben).

Beachten Sie, dass Sie mit Factory-Mustern immer durchkommen können, indem Sie zwei Bedingungen miteinander kombinieren (was die Codekomplexität und die Kopplung geringfügig erhöht). Ich denke, deshalb sehen wir selten reale Anwendungsfälle von Abstract Factory-Mustern.